@openbim/ifcx 0.1.0 → 0.2.0

package/bundler/openbim_ifcx_wasm_bg.js

@@ -0,0 +1,481 @@
+/**
+ * One IFCX file. Writing it back is lossless: key order, unknown fields,
+ * `null` deletions and every number stay as read.
+ *
+ * A newtype because `wasm_bindgen` can only export a type defined in this
+ * crate; all state and behaviour are the core's.
+ */
+export class IfcxFile {
+    static __wrap(ptr) {
+        const obj = Object.create(IfcxFile.prototype);
+        obj.__wbg_ptr = ptr;
+        IfcxFileFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IfcxFileFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ifcxfile_free(ptr, 0);
+    }
+    /**
+     * The `header` object.
+     * @returns {Record<string, unknown>}
+     */
+    get header() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_header(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Number of entries in `data`; several may share a path.
+     * @returns {number}
+     */
+    get nodeCount() {
+        const ret = wasm.ifcxfile_nodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Read an IFCX file from its JSON text or UTF-8 bytes.
+     * @param {IfcxInput} input
+     * @returns {IfcxFile}
+     */
+    static parse(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_parse(retptr, addBorrowedObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return IfcxFile.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * The file as a plain object, so `JSON.stringify(file)` works. Unlike
+     * `write`, a plain object may reorder integer-like keys and round
+     * integers beyond 2^53.
+     * @returns {Record<string, unknown>}
+     */
+    toJSON() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_toJSON(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Check every attribute against this file's own `schemas`. Imports are
+     * not resolved; use the `validate` function to include them.
+     * @returns {ValidationReport}
+     */
+    validate() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_validate(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The file as JSON text; `pretty` indents it by two spaces.
+     * @param {boolean | null} [pretty]
+     * @returns {string}
+     */
+    write(pretty) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_write(retptr, this.__wbg_ptr, isLikeNone(pretty) ? 0xFFFFFF : pretty ? 1 : 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) IfcxFile.prototype[Symbol.dispose] = IfcxFile.prototype.free;
+
+/**
+ * Compose layers, weakest first, into a tree of plain objects: the
+ * artificial root (path `""`) over every root node. Declared for
+ * TypeScript in `TYPES`, where `options` can be optional.
+ * @param {any} layers
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function compose(layers, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.compose(retptr, addBorrowedObject(layers), isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+ * Compose layers, weakest first, and write their render scene as GLB
+ * bytes. Declared for TypeScript in `TYPES`.
+ * @param {any} layers
+ * @param {any | null} [options]
+ * @returns {Uint8Array}
+ */
+export function exportGlb(layers, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.exportGlb(retptr, addBorrowedObject(layers), isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+ * Check the attributes of the layers, weakest first, against the schemas
+ * of every layer (and of resolved imports), after merging nodes that share
+ * a path. Declared for TypeScript in `TYPES`.
+ * @param {any} layers
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function validate(layers, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.validate(retptr, addBorrowedObject(layers), isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+    }
+}
+export function __wbg___wbindgen_boolean_get_7a12af2b3f899c5a(arg0) {
+    const v = getObject(arg0);
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+}
+export function __wbg___wbindgen_is_null_5160b3e381865372(arg0) {
+    const ret = getObject(arg0) === null;
+    return ret;
+}
+export function __wbg___wbindgen_is_object_edb6b15aa3afe12e(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_8c687d0b90d5b524(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_string_get_92ab86bb19cbc12f(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg___wbindgen_throw_5d9e815e6fdf150f(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_entries_20b9608d57d8ddd6(arg0) {
+    const ret = getObject(arg0).entries();
+    return addHeapObject(ret);
+}
+export function __wbg_entries_972a87586902cf87(arg0) {
+    const ret = Object.entries(getObject(arg0));
+    return addHeapObject(ret);
+}
+export function __wbg_from_a39669ce566077da(arg0) {
+    const ret = Array.from(getObject(arg0));
+    return addHeapObject(ret);
+}
+export function __wbg_get_989d0a1309644f2b() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_get_b1f0ab13c737f856(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+}
+export function __wbg_get_unchecked_363572bdd397d473(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+}
+export function __wbg_instanceof_Map_1ff6a2b54c899f0d(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Uint8Array_598adc0fef426aa8(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_5674713bb7b79043(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+}
+export function __wbg_length_31bdaf014f5fbde2(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+}
+export function __wbg_length_4e1adc0d42e23620(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+}
+export function __wbg_new_a32a1ab6c6655abe(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+}
+export function __wbg_new_from_slice_4ee02165f9de919e(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+}
+export function __wbg_parse_6937a9050adfb0e1() { return handleError(function (arg0, arg1) {
+    const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_prototypesetcall_ae9f5e7459250748(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+}
+export function __wbg_set_a377297433dfea63() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+    return ret;
+}, arguments); }
+export function __wbg_set_name_6e2a5da46a9ae1e7(arg0, arg1, arg2) {
+    getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+}
+export function __wbindgen_generic_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+}
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+}
+const IfcxFileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ifcxfile_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+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 getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+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;
+}
+
+let stack_pointer = 1024;
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+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 wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/bundler/openbim_ifcx_wasm_bg.wasm.d.ts

@@ -0,0 +1,18 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_ifcxfile_free: (a: number, b: number) => void;
+export const compose: (a: number, b: number, c: number) => void;
+export const exportGlb: (a: number, b: number, c: number) => void;
+export const ifcxfile_header: (a: number, b: number) => void;
+export const ifcxfile_nodeCount: (a: number) => number;
+export const ifcxfile_parse: (a: number, b: number) => void;
+export const ifcxfile_toJSON: (a: number, b: number) => void;
+export const ifcxfile_validate: (a: number, b: number) => void;
+export const ifcxfile_write: (a: number, b: number, c: number) => void;
+export const validate: (a: number, b: number, c: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;

package/bundler/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/fetch-imports.d.ts

@@ -0,0 +1,53 @@
+import type { IfcxInput } from "./openbim_ifcx_wasm.js";
+
+/** The part of a `fetch` `Response` that `fetchImports` reads. */
+export interface FetchedResponse {
+  ok?: boolean;
+  status?: number;
+  statusText?: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+}
+
+/**
+ * Loads one imported file. `fetch` itself fits; a custom function may also
+ * return the file directly. `url` is the import `uri` resolved against the
+ * importing file's URL (or `baseUrl`); when a relative `uri` has no base to
+ * resolve against, a custom function receives the `uri` unchanged.
+ */
+export type ImportFetcher = (
+  url: string,
+  init?: { signal?: AbortSignal },
+) => Promise<FetchedResponse | IfcxInput | ArrayBuffer>;
+
+/** Options for `fetchImports`. */
+export interface FetchImportsOptions {
+  /**
+   * URL that relative import URIs of the given layers resolve against.
+   * Defaults to `location.href` in a browser. Imports of a fetched file
+   * resolve against that file's URL.
+   */
+  baseUrl?: string | URL;
+  /** Loads each file. Defaults to the global `fetch`. */
+  fetch?: ImportFetcher;
+  /** Files already at hand, keyed by import `uri`; never fetched again. */
+  imports?: Record<string, IfcxInput> | Map<string, IfcxInput>;
+  /** Passed to every fetch call. */
+  signal?: AbortSignal;
+}
+
+/**
+ * Fetch every file the layers import, recursively and each `uri` once, and
+ * return them keyed by the exact import `uri`: the `imports` option of
+ * `compose`, `validate` and `exportGlb`. Network access happens here, in
+ * JavaScript; the WebAssembly module never fetches anything. A file that
+ * cannot be fetched rejects with an `IfcxError` whose `code` is `"fetch"`.
+ *
+ * ```js
+ * const imports = await fetchImports(layers, { baseUrl: "https://example.org/model/" });
+ * const tree = compose(layers, { imports });
+ * ```
+ */
+export function fetchImports(
+  layers: IfcxInput | IfcxInput[],
+  options?: FetchImportsOptions,
+): Promise<Map<string, IfcxInput>>;

package/fetch-imports.js

@@ -0,0 +1,139 @@
+"use strict";
+// Import resolution over `fetch`, for the `imports` option of `compose`,
+// `validate` and `exportGlb`.
+//
+// Plain JavaScript on purpose: the Rust crates perform no network access
+// (ADR 0002), so the binding resolves imports in memory only and this
+// module does the fetching on the JavaScript side. It reads each layer's
+// `imports` list, fetches every named file (recursively, each URI once) and
+// returns the files keyed by their exact import `uri`, which is what the
+// in-memory `imports` option expects. Integrity values are checked later,
+// by the binding, against the fetched bytes.
+//
+// This file is the ES module source. scripts/build-npm-pkg.sh copies it into
+// the `web` and `bundler` builds and derives the CommonJS copy for the Node
+// build from it, so it must stay self-contained: no imports, and every
+// export a top-level `export async function` or `export function`.
+
+/** The imports of an IFCX file, or none when it is not readable JSON. */
+function importUris(input) {
+  let text = input;
+  if (typeof input !== "string") {
+    text = new TextDecoder().decode(input);
+  }
+  let file;
+  try {
+    file = JSON.parse(text);
+  } catch {
+    // Not JSON: the binding call that receives it reports where.
+    return [];
+  }
+  const imports = file !== null && typeof file === "object" ? file.imports : undefined;
+  if (!Array.isArray(imports)) return [];
+  return imports
+    .map((entry) => (entry !== null && typeof entry === "object" ? entry.uri : undefined))
+    .filter((uri) => typeof uri === "string");
+}
+
+function fetchError(message, cause) {
+  const error = new Error(message, cause === undefined ? undefined : { cause });
+  error.name = "IfcxError";
+  error.code = "fetch";
+  return error;
+}
+
+function isInput(value) {
+  return typeof value === "string" || value instanceof Uint8Array;
+}
+
+/** The URL `uri` names, relative to `base`; `undefined` if it cannot be resolved. */
+function resolveUrl(uri, base) {
+  try {
+    return base === undefined ? new URL(uri).href : new URL(uri, base).href;
+  } catch {
+    return undefined;
+  }
+}
+
+/** What a fetch function returned, as an IFCX input. */
+async function readResponse(response, uri, url) {
+  if (isInput(response)) return response;
+  if (response instanceof ArrayBuffer) return new Uint8Array(response);
+  if (response !== null && typeof response === "object" && typeof response.arrayBuffer === "function") {
+    if (response.ok === false) {
+      const status = [response.status, response.statusText].filter(Boolean).join(" ");
+      throw fetchError(`could not fetch import ${JSON.stringify(uri)} from ${url}: HTTP ${status}`);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  throw fetchError(
+    `the fetch function returned neither a Response, a Uint8Array, an ArrayBuffer nor a string for ${JSON.stringify(uri)}`,
+  );
+}
+
+/**
+ * Fetch every file the layers import, recursively, keyed by the exact
+ * import `uri`, for the `imports` option of `compose`, `validate` and
+ * `exportGlb`.
+ */
+async function fetchImports(layers, options = {}) {
+  const list = Array.isArray(layers) ? layers : [layers];
+  for (const layer of list) {
+    if (!isInput(layer)) {
+      throw fetchError("every layer must be a string or a Uint8Array");
+    }
+  }
+  const fetcher = options.fetch ?? globalThis.fetch;
+  if (typeof fetcher !== "function") {
+    throw fetchError("no fetch function: pass options.fetch");
+  }
+  const custom = options.fetch !== undefined;
+  const base =
+    options.baseUrl !== undefined ? String(options.baseUrl) : globalThis.location?.href;
+  const init = options.signal === undefined ? undefined : { signal: options.signal };
+
+  const found = new Map();
+  if (options.imports !== undefined) {
+    const known = options.imports instanceof Map ? options.imports : Object.entries(options.imports);
+    for (const [uri, file] of known) found.set(uri, file);
+  }
+
+  // Breadth first; each level's fetches run concurrently. `url` is where a
+  // layer came from, so its relative imports resolve against it.
+  let level = list.map((file) => ({ file, url: base }));
+  for (const [, file] of found) level.push({ file, url: base });
+  while (level.length > 0) {
+    const pending = [];
+    for (const { file, url: importer } of level) {
+      for (const uri of importUris(file)) {
+        if (found.has(uri)) continue;
+        found.set(uri, undefined); // claimed: fetch each URI once
+        const url = resolveUrl(uri, importer);
+        if (url === undefined && !custom) {
+          throw fetchError(
+            `cannot resolve import ${JSON.stringify(uri)} to a URL: pass options.baseUrl`,
+          );
+        }
+        pending.push(
+          (async () => {
+            let response;
+            try {
+              response = await fetcher(url ?? uri, init);
+            } catch (error) {
+              throw fetchError(
+                `could not fetch import ${JSON.stringify(uri)} from ${url ?? uri}: ${error?.message ?? error}`,
+                error,
+              );
+            }
+            const fetched = await readResponse(response, uri, url ?? uri);
+            found.set(uri, fetched);
+            return { file: fetched, url: url ?? importer };
+          })(),
+        );
+      }
+    }
+    level = await Promise.all(pending);
+  }
+  return found;
+}
+exports.fetchImports = fetchImports;