nucleation 0.1.18 → 0.1.20

package/nucleation-cdn-loader.js

@@ -1,34 +1,15 @@
-// nucleation-cdn-loader.js - Custom loader for CDN usage
-import * as bgModule from './nucleation_bg.js';
+// This loader is for use in a browser via <script type="module"> from a CDN.
+// It ensures that the .wasm file is loaded from the correct relative path.
 
-let initialized = false;
+// Import the real init function and all the classes from the original module.
+import init, * as wasm from './nucleation-original.js';
 
-// The init function is the default export for this file.
-async function init(wasmPathOrModule) {
-    if (initialized) {
-        return { ...bgModule };
-    }
-    if (typeof bgModule.__wbg_set_wasm !== 'function') {
-        throw new Error("Missing __wbg_set_wasm in ./nucleation_bg.js");
-    }
-
-    let input = wasmPathOrModule;
-    if (input === undefined) {
-        input = new URL('./nucleation_bg.wasm', import.meta.url);
-    }
-
-    const importsObject = { './nucleation_bg.js': bgModule };
-    const { instance } = await WebAssembly.instantiateStreaming(fetch(input), importsObject);
-
-    bgModule.__wbg_set_wasm(instance.exports);
-    initialized = true;
-
-    // Return all the exports from the bg module
-    return { ...bgModule };
+// The default export is a new initializer function for CDN use.
+// It calls the real 'init' but provides the URL to the .wasm file.
+export default async function() {
+  const wasmUrl = new URL('./nucleation_bg.wasm', import.meta.url);
+  await init(wasmUrl);
 }
 
-// Re-export the named items so users can do:
-// import init, { SchematicWrapper } from '.../loader.js';
-// This works because after init() is called, these exports become "live".
-export * from './nucleation_bg.js';
-export default init;
+// Re-export all the named classes (SchematicWrapper, etc.).
+export * from './nucleation-original.js';

package/{nucleation_bg.js → nucleation-original.js}

@@ -1,8 +1,4 @@
 let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}
-
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -95,9 +91,7 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
-
-let cachedTextEncoder = new lTextEncoder('utf-8');
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
@@ -164,11 +158,9 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
-let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
 
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
@@ -695,120 +687,209 @@ export class SchematicWrapper {
     }
 }
 
-export function __wbg_get_67b2ba62fc30de12() { return handleError(function (arg0, arg1) {
-    const ret = Reflect.get(arg0, arg1);
-    return ret;
-}, arguments) };
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
 
-export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) {
-    const ret = arg0[arg1 >>> 0];
-    return ret;
-};
+            } catch (e) {
+                if (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);
 
-export function __wbg_instanceof_Object_7f2dcef8f78644a4(arg0) {
-    let result;
-    try {
-        result = arg0 instanceof Object;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-};
-
-export function __wbg_isArray_a1eab7e0d067391b(arg0) {
-    const ret = Array.isArray(arg0);
-    return ret;
-};
-
-export function __wbg_keys_5c77a08ddc2fb8a6(arg0) {
-    const ret = Object.keys(arg0);
-    return ret;
-};
-
-export function __wbg_length_e2d2a49132c1b256(arg0) {
-    const ret = arg0.length;
-    return ret;
-};
-
-export function __wbg_log_c222819a41e063d3(arg0) {
-    console.log(arg0);
-};
-
-export function __wbg_new_405e22f390576ce2() {
-    const ret = new Object();
-    return ret;
-};
-
-export function __wbg_new_78feb108b6472713() {
-    const ret = new Array();
-    return ret;
-};
-
-export function __wbg_now_807e54c39636c349() {
-    const ret = Date.now();
-    return ret;
-};
-
-export function __wbg_push_737cfc8c1432c2c6(arg0, arg1) {
-    const ret = arg0.push(arg1);
-    return ret;
-};
-
-export function __wbg_set_bb8cecf6a62b9f46() { return handleError(function (arg0, arg1, arg2) {
-    const ret = Reflect.set(arg0, arg1, arg2);
-    return ret;
-}, arguments) };
-
-export function __wbindgen_debug_string(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);
-};
-
-export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_export_2;
-    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);
-    ;
-};
-
-export function __wbindgen_is_null(arg0) {
-    const ret = arg0 === null;
-    return ret;
-};
-
-export function __wbindgen_is_undefined(arg0) {
-    const ret = arg0 === undefined;
-    return ret;
-};
-
-export function __wbindgen_number_new(arg0) {
-    const ret = arg0;
-    return ret;
-};
-
-export function __wbindgen_string_get(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);
-};
-
-export function __wbindgen_string_new(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-};
-
-export function __wbindgen_throw(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
+                } 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 __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Object_7f2dcef8f78644a4 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Object;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
+        const ret = Array.isArray(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_keys_5c77a08ddc2fb8a6 = function(arg0) {
+        const ret = Object.keys(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_log_c222819a41e063d3 = function(arg0) {
+        console.log(arg0);
+    };
+    imports.wbg.__wbg_new_405e22f390576ce2 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_78feb108b6472713 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_now_807e54c39636c349 = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_push_737cfc8c1432c2c6 = function(arg0, arg1) {
+        const ret = arg0.push(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_set_bb8cecf6a62b9f46 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbindgen_debug_string = 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);
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_2;
+        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);
+        ;
+    };
+    imports.wbg.__wbindgen_is_null = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_get = 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);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedInt32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof 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();
+
+    __wbg_init_memory(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 (typeof 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 (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('nucleation_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);
+    }
+
+    __wbg_init_memory(imports);
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
 
+export { initSync };
+export default __wbg_init;

package/nucleation.d.ts

@@ -1,4 +1,123 @@
-import * as wasm from './nucleation_bg';
-export * from './nucleation_bg';
-declare const wasmPromise: Promise<typeof wasm>;
-export default wasmPromise;
+/* tslint:disable */
+/* eslint-disable */
+export function start(): void;
+export function debug_schematic(schematic: SchematicWrapper): string;
+export function debug_json_schematic(schematic: SchematicWrapper): string;
+export class BlockPosition {
+  free(): void;
+  constructor(x: number, y: number, z: number);
+  x: number;
+  y: number;
+  z: number;
+}
+export class BlockStateWrapper {
+  free(): void;
+  constructor(name: string);
+  with_property(key: string, value: string): void;
+  name(): string;
+  properties(): any;
+}
+export class SchematicWrapper {
+  free(): void;
+  constructor();
+  from_data(data: Uint8Array): void;
+  from_litematic(data: Uint8Array): void;
+  to_litematic(): Uint8Array;
+  from_schematic(data: Uint8Array): void;
+  to_schematic(): Uint8Array;
+  set_block(x: number, y: number, z: number, block_name: string): void;
+  set_block_from_string(x: number, y: number, z: number, block_string: string): void;
+  copy_region(from_schematic: SchematicWrapper, min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, target_x: number, target_y: number, target_z: number, excluded_blocks: any): void;
+  set_block_with_properties(x: number, y: number, z: number, block_name: string, properties: any): void;
+  get_block(x: number, y: number, z: number): string | undefined;
+  get_block_with_properties(x: number, y: number, z: number): BlockStateWrapper | undefined;
+  get_block_entity(x: number, y: number, z: number): any;
+  get_all_block_entities(): any;
+  print_schematic(): string;
+  debug_info(): string;
+  get_dimensions(): Int32Array;
+  get_block_count(): number;
+  get_volume(): number;
+  get_region_names(): string[];
+  blocks(): Array<any>;
+  chunks(chunk_width: number, chunk_height: number, chunk_length: number): Array<any>;
+  chunks_with_strategy(chunk_width: number, chunk_height: number, chunk_length: number, strategy: string, camera_x: number, camera_y: number, camera_z: number): Array<any>;
+  get_chunk_blocks(offset_x: number, offset_y: number, offset_z: number, width: number, height: number, length: number): Array<any>;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_schematicwrapper_free: (a: number, b: number) => void;
+  readonly __wbg_blockstatewrapper_free: (a: number, b: number) => void;
+  readonly schematicwrapper_new: () => number;
+  readonly schematicwrapper_from_data: (a: number, b: number, c: number) => [number, number];
+  readonly schematicwrapper_from_litematic: (a: number, b: number, c: number) => [number, number];
+  readonly schematicwrapper_to_litematic: (a: number) => [number, number, number, number];
+  readonly schematicwrapper_from_schematic: (a: number, b: number, c: number) => [number, number];
+  readonly schematicwrapper_to_schematic: (a: number) => [number, number, number, number];
+  readonly schematicwrapper_set_block: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly schematicwrapper_set_block_from_string: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+  readonly schematicwrapper_copy_region: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: any) => [number, number];
+  readonly schematicwrapper_set_block_with_properties: (a: number, b: number, c: number, d: number, e: number, f: number, g: any) => [number, number];
+  readonly schematicwrapper_get_block: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly schematicwrapper_get_block_with_properties: (a: number, b: number, c: number, d: number) => number;
+  readonly schematicwrapper_get_block_entity: (a: number, b: number, c: number, d: number) => any;
+  readonly schematicwrapper_get_all_block_entities: (a: number) => any;
+  readonly schematicwrapper_print_schematic: (a: number) => [number, number];
+  readonly schematicwrapper_debug_info: (a: number) => [number, number];
+  readonly schematicwrapper_get_dimensions: (a: number) => [number, number];
+  readonly schematicwrapper_get_block_count: (a: number) => number;
+  readonly schematicwrapper_get_volume: (a: number) => number;
+  readonly schematicwrapper_get_region_names: (a: number) => [number, number];
+  readonly schematicwrapper_blocks: (a: number) => any;
+  readonly schematicwrapper_chunks: (a: number, b: number, c: number, d: number) => any;
+  readonly schematicwrapper_chunks_with_strategy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
+  readonly schematicwrapper_get_chunk_blocks: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+  readonly blockstatewrapper_new: (a: number, b: number) => number;
+  readonly blockstatewrapper_with_property: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly blockstatewrapper_name: (a: number) => [number, number];
+  readonly blockstatewrapper_properties: (a: number) => any;
+  readonly debug_schematic: (a: number) => [number, number];
+  readonly debug_json_schematic: (a: number) => [number, number];
+  readonly start: () => void;
+  readonly __wbg_blockposition_free: (a: number, b: number) => void;
+  readonly __wbg_get_blockposition_x: (a: number) => number;
+  readonly __wbg_set_blockposition_x: (a: number, b: number) => void;
+  readonly __wbg_get_blockposition_y: (a: number) => number;
+  readonly __wbg_set_blockposition_y: (a: number, b: number) => void;
+  readonly __wbg_get_blockposition_z: (a: number) => number;
+  readonly __wbg_set_blockposition_z: (a: number, b: number) => void;
+  readonly blockposition_new: (a: number, b: number, c: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __externref_drop_slice: (a: number, b: 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/nucleation.js

@@ -1,6 +1,36 @@
-import init, * as wasm from './nucleation_bg.js';
+// Universal WASM initializer that works in both Node.js and browsers
+import init_wasm from './nucleation-original.js';
 
-// The default export is a promise that resolves with the initialized wasm exports.
-// Bundlers will automatically resolve the path to the wasm file.
-const wasmPromise = init().then(() => wasm);
-export default wasmPromise;
+export default async function init(input) {
+  // If input is provided, use it directly (manual override)
+  if (input !== undefined) {
+    return await init_wasm(input);
+  }
+
+  // Auto-detect environment
+  const isNode = typeof process !== 'undefined' && process.versions?.node;
+
+  if (isNode) {
+    // Node.js: read the WASM file directly
+    try {
+      const fs = await import('fs');
+      const path = await import('path');
+      const url = await import('url');
+
+      const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+      const wasmPath = path.join(__dirname, 'nucleation_bg.wasm');
+      const wasmBytes = fs.readFileSync(wasmPath);
+
+      return await init_wasm(wasmBytes);
+    } catch (error) {
+      console.warn('Failed to load WASM in Node.js, trying default init:', error.message);
+      return await init_wasm();
+    }
+  } else {
+    // Browser: use default fetch behavior
+    return await init_wasm();
+  }
+}
+
+// Re-export everything from the original module
+export * from './nucleation-original.js';

package/package.json

@@ -5,7 +5,7 @@
     "Nano nano@schem.at"
   ],
   "description": "A high-performance Minecraft schematic parser and utility library",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
@@ -13,9 +13,9 @@
   },
   "files": [
     "nucleation.js",
-    "nucleation_bg.wasm",
-    "nucleation_bg.js",
+    "nucleation-original.js",
     "nucleation.d.ts",
+    "nucleation_bg.wasm",
     "nucleation_bg.d.ts",
     "nucleation-cdn-loader.js",
     "README.md"
@@ -23,7 +23,6 @@
   "main": "./nucleation.js",
   "types": "./nucleation.d.ts",
   "sideEffects": [
-    "./nucleation.js",
     "./snippets/*"
   ],
   "keywords": [