@spyglassmc/core 0.4.45 → 0.4.47

package/lib/common/Dev.d.ts

@@ -1,7 +1,7 @@
 export declare namespace Dev {
     function assertDefined<T>(value: T): asserts value is Exclude<T, undefined>;
     function assertNever(value: never): never;
-    function assertTrue(value: boolean, message: string): void;
+    function assertTrue(value: unknown, message: string): asserts value;
     /**
      * @returns An estimate of the memory taken by the given value, assuming objects are stored as array-like structures instead of dictionaries in the V8 engine.
      */

package/lib/common/Dev.js

@@ -1,3 +1,4 @@
+import { bigintJsonNumberReplacer } from './index.js';
 export var Dev;
 (function (Dev) {
     function assertDefined(value) {
@@ -68,12 +69,12 @@ export var Dev;
         if (value && typeof value === 'object') {
             try {
                 const seen = new Set();
-                return JSON.stringify(value, (_k, v) => {
+                return JSON.stringify(value, (k, v) => {
                     if (v && typeof v === 'object') {
                         return seen.has(v) ? '[Circular]' : (seen.add(v), v);
                     }
                     else {
-                        return v;
+                        return bigintJsonNumberReplacer(k, v);
                     }
                 });
             }

package/lib/common/EventDispatcher.d.ts

@@ -0,0 +1,6 @@
+export declare class EventDispatcher<TEvents extends Record<string, unknown>> {
+    #private;
+    emit<K extends keyof TEvents & string>(name: K, data: TEvents[K]): void;
+    on<K extends keyof TEvents & string>(name: K, listener: (data: TEvents[K]) => unknown, options?: AddEventListenerOptions): this;
+}
+//# sourceMappingURL=EventDispatcher.d.ts.map

package/lib/common/EventDispatcher.js

@@ -0,0 +1,15 @@
+import { Dev } from './Dev.js';
+export class EventDispatcher {
+    #target = new EventTarget();
+    emit(name, data) {
+        this.#target.dispatchEvent(new CustomEvent(name, { detail: data }));
+    }
+    on(name, listener, options) {
+        this.#target.addEventListener(name, (event) => {
+            Dev.assertTrue(event instanceof CustomEvent, 'event must be an instance of CustomEvent');
+            listener(event.detail);
+        }, options);
+        return this;
+    }
+}
+//# sourceMappingURL=EventDispatcher.js.map

package/lib/common/ReadonlyProxy.js

@@ -1,4 +1,4 @@
-import { emplaceMap, isObject } from './util.js';
+import { getOrInsertComputed, isObject } from './util.js';
 export var ReadonlyProxy;
 (function (ReadonlyProxy) {
     function create(obj) {
@@ -11,7 +11,7 @@ class ReadonlyProxyHandler {
     get(target, p, receiver) {
         const value = Reflect.get(target, p, receiver);
         if (p !== 'prototype' && isObject(value)) {
-            return emplaceMap(this.map, p, { insert: () => ReadonlyProxy.create(value) });
+            return getOrInsertComputed(this.map, p, () => ReadonlyProxy.create(value));
         }
         return value;
     }

package/lib/common/StateProxy.js

@@ -1,4 +1,4 @@
-import { emplaceMap, isObject } from '../common/index.js';
+import { getOrInsertComputed, isObject } from '../common/index.js';
 import { Operations } from './Operations.js';
 const BranchOff = Symbol('StateBranchOff');
 const Is = Symbol('IsStateProxy');
@@ -63,7 +63,7 @@ class StateProxyHandler {
         }
         const value = Reflect.get(target, p, receiver);
         if (p !== 'prototype' && isObject(value)) {
-            return emplaceMap(this.map, p, { insert: () => _createStateProxy(value, this.rootOps) });
+            return getOrInsertComputed(this.map, p, () => _createStateProxy(value, this.rootOps));
         }
         return value;
     }

package/lib/common/externals/BrowserExternals.d.ts

@@ -1,11 +1,3 @@
-import type { ExternalEventEmitter, Externals } from './index.js';
-type Listener = (...args: unknown[]) => unknown;
-export declare class BrowserEventEmitter implements ExternalEventEmitter {
-    #private;
-    emit(eventName: string, ...args: unknown[]): boolean;
-    on(eventName: string, listener: Listener): this;
-    once(eventName: string, listener: Listener): this;
-}
+import type { Externals } from './index.js';
 export declare const BrowserExternals: Externals;
-export {};
 //# sourceMappingURL=BrowserExternals.d.ts.map

package/lib/common/externals/BrowserExternals.js

@@ -1,40 +1,5 @@
 import { decode as arrayBufferFromBase64, encode as arrayBufferToBase64 } from 'base64-arraybuffer';
-import pako from 'pako';
 import { fileUtil } from '../../service/fileUtil.js';
-export class BrowserEventEmitter {
-    #listeners = new Map();
-    emit(eventName, ...args) {
-        const listeners = this.#listeners.get(eventName);
-        if (!listeners?.all?.size) {
-            return false;
-        }
-        for (const listener of listeners.all) {
-            listener(...args);
-            if (listeners.once.has(listener)) {
-                listeners.all.delete(listener);
-                listeners.once.delete(listener);
-            }
-        }
-        return false;
-    }
-    on(eventName, listener) {
-        if (!this.#listeners.has(eventName)) {
-            this.#listeners.set(eventName, { all: new Set(), once: new Set() });
-        }
-        const listeners = this.#listeners.get(eventName);
-        listeners.all.add(listener);
-        return this;
-    }
-    once(eventName, listener) {
-        if (!this.#listeners.has(eventName)) {
-            this.#listeners.set(eventName, { all: new Set(), once: new Set() });
-        }
-        const listeners = this.#listeners.get(eventName);
-        listeners.all.add(listener);
-        listeners.once.add(listener);
-        return this;
-    }
-}
 // TODO: Use Origin Private File System (OPFS) instead
 class BrowserFileSystem {
     static LocalStorageKey = 'spyglassmc-browser-fs';
@@ -113,21 +78,6 @@ export const BrowserExternals = {
         decompressBall(_buffer, _options) {
             throw new Error('decompressBall not supported on browser.');
         },
-        async gunzip(buffer) {
-            return pako.inflate(buffer);
-        },
-        async gzip(buffer) {
-            return pako.gzip(buffer);
-        },
-    },
-    crypto: {
-        async getSha1(data) {
-            if (typeof data === 'string') {
-                data = new TextEncoder().encode(data);
-            }
-            const hash = await crypto.subtle.digest('SHA-1', data.buffer);
-            return uint8ArrayToHex(new Uint8Array(hash));
-        },
     },
     error: {
         createKind(kind, message) {
@@ -137,19 +87,10 @@ export const BrowserExternals = {
             return e instanceof Error && e.message.startsWith(kind);
         },
     },
-    event: { EventEmitter: BrowserEventEmitter },
     fs: new BrowserFileSystem(),
     web: {
-        fetch,
         getCache: () => window.caches.open('spyglassmc'),
     },
 };
-function uint8ArrayToHex(array) {
-    let ans = '';
-    for (const v of array) {
-        ans += v.toString(16).padStart(2, '0');
-    }
-    return ans;
-}
 Object.freeze(BrowserExternals);
 //# sourceMappingURL=BrowserExternals.js.map

package/lib/common/externals/NodeJsExternals.d.ts

@@ -1,4 +1,3 @@
-import { EventEmitter } from 'node:events';
 import fs, { promises as fsp } from 'node:fs';
 import type { DecompressedFile, RootUriString } from '../../index.js';
 import type { FsLocation } from './index.js';
@@ -10,19 +9,11 @@ export declare function getNodeJsExternals({ cacheRoot, nodeFsp }?: {
         decompressBall(buffer: Uint8Array<ArrayBuffer>, options: {
             stripLevel?: number;
         } | undefined): Promise<DecompressedFile[]>;
-        gunzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-        gzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-    };
-    crypto: {
-        getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
     };
     error: {
         createKind(kind: import("./index.js").ExternalErrorKind, message: string): Error;
         isKind(e: unknown, kind: import("./index.js").ExternalErrorKind): boolean;
     };
-    event: {
-        EventEmitter: typeof EventEmitter;
-    };
     fs: {
         chmod(location: FsLocation, mode: number): Promise<void>;
         mkdir(location: FsLocation, options: {
@@ -42,7 +33,6 @@ export declare function getNodeJsExternals({ cacheRoot, nodeFsp }?: {
         } | undefined): Promise<void>;
     };
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<HttpCache>;
     };
 }>;
@@ -51,19 +41,11 @@ export declare const NodeJsExternals: Readonly<{
         decompressBall(buffer: Uint8Array<ArrayBuffer>, options: {
             stripLevel?: number;
         } | undefined): Promise<DecompressedFile[]>;
-        gunzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-        gzip(buffer: Uint8Array<ArrayBuffer>): Promise<NonSharedBuffer>;
-    };
-    crypto: {
-        getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
     };
     error: {
         createKind(kind: import("./index.js").ExternalErrorKind, message: string): Error;
         isKind(e: unknown, kind: import("./index.js").ExternalErrorKind): boolean;
     };
-    event: {
-        EventEmitter: typeof EventEmitter;
-    };
     fs: {
         chmod(location: FsLocation, mode: number): Promise<void>;
         mkdir(location: FsLocation, options: {
@@ -83,7 +65,6 @@ export declare const NodeJsExternals: Readonly<{
         } | undefined): Promise<void>;
     };
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<HttpCache>;
     };
 }>;

package/lib/common/externals/NodeJsExternals.js

@@ -1,17 +1,12 @@
 import decompress from 'decompress';
 import { Buffer } from 'node:buffer';
 import cp from 'node:child_process';
-import crypto from 'node:crypto';
-import { EventEmitter } from 'node:events';
 import fs, { promises as fsp } from 'node:fs';
 import os from 'node:os';
 import process from 'node:process';
 import stream from 'node:stream';
 import url from 'node:url';
 import { promisify } from 'node:util';
-import zlib from 'node:zlib';
-const gunzip = promisify(zlib.gunzip);
-const gzip = promisify(zlib.gzip);
 export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
     return Object.freeze({
         archive: {
@@ -21,19 +16,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
                 }
                 return decompress(buffer, { strip: options?.stripLevel });
             },
-            gunzip(buffer) {
-                return gunzip(buffer);
-            },
-            gzip(buffer) {
-                return gzip(buffer);
-            },
-        },
-        crypto: {
-            async getSha1(data) {
-                const hash = crypto.createHash('sha1');
-                hash.update(data);
-                return hash.digest('hex');
-            },
         },
         error: {
             createKind(kind, message) {
@@ -45,7 +27,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
                 return e instanceof Error && e.code === kind;
             },
         },
-        event: { EventEmitter },
         fs: {
             chmod(location, mode) {
                 return nodeFsp.chmod(toFsPathLike(location), mode);
@@ -92,7 +73,6 @@ export function getNodeJsExternals({ cacheRoot, nodeFsp = fsp } = {}) {
             },
         },
         web: {
-            fetch,
             getCache: async () => {
                 return new HttpCache(cacheRoot);
             },

package/lib/common/externals/index.d.ts

@@ -4,14 +4,6 @@ export interface Externals {
         decompressBall: (buffer: Uint8Array<ArrayBuffer>, options?: {
             stripLevel?: number;
         }) => Promise<DecompressedFile[]>;
-        gzip: (buffer: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
-        gunzip: (buffer: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
-    };
-    crypto: {
-        /**
-         * @returns SHA-1 digest of the given data in hexadecimal format.
-         */
-        getSha1: (data: string | Uint8Array<ArrayBuffer>) => Promise<string>;
     };
     error: {
         /**
@@ -23,12 +15,8 @@ export interface Externals {
          */
         isKind: (e: unknown, kind: ExternalErrorKind) => boolean;
     };
-    event: {
-        EventEmitter: new () => ExternalEventEmitter;
-    };
     fs: ExternalFileSystem;
     web: {
-        fetch: typeof fetch;
         getCache: () => Promise<Cache>;
     };
 }
@@ -40,11 +28,6 @@ export interface DecompressedFile {
     type: string;
 }
 export type ExternalErrorKind = 'EEXIST' | 'EISDIR' | 'ENOENT';
-export interface ExternalEventEmitter {
-    emit(eventName: string, ...args: unknown[]): boolean;
-    on(eventName: string, listener: (...args: unknown[]) => unknown): this;
-    once(eventName: string, listener: (...args: unknown[]) => unknown): this;
-}
 export interface ExternalFileSystem {
     /**
      * @param mode File mode bit mask (e.g. `0o775`).

package/lib/common/index.d.ts

@@ -1,5 +1,7 @@
 export * from './Dev.js';
+export * from './EventDispatcher.js';
 export * from './externals/index.js';
+export * from './json.js';
 export * from './Logger.js';
 export * from './Operations.js';
 export * from './ReadonlyProxy.js';

package/lib/common/index.js

@@ -1,5 +1,7 @@
 export * from './Dev.js';
+export * from './EventDispatcher.js';
 export * from './externals/index.js';
+export * from './json.js';
 export * from './Logger.js';
 export * from './Operations.js';
 export * from './ReadonlyProxy.js';

package/lib/common/json.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Json replacer that writes bigints as a json string of the form `"$$type:bigint;$$value:91"`.
+ * Intended to be used with `bigintJsonLosslessReviver`
+ * @param _key The key at which the value lives
+ * @param value The value to encode
+ * @returns Replaced value
+ */
+export declare function bigintJsonLosslessReplacer(_key: string, value: any): any;
+/**
+ * Json reviver that revives bigints encoded by `bigintJsonLosslessReplacer`
+ * @param _key
+ * @param value
+ * @returns
+ */
+export declare function bigintJsonLosslessReviver(_key: string, value: any): any;
+/**
+ * Json replacer that replaces bigints with raw json number literals, encoding the entire number.
+ * @param _key The key at which the value lives
+ * @param value The value to encode
+ * @returns Replaced value
+ */
+export declare function bigintJsonNumberReplacer(_key: string, value: any): any;
+/**
+ * Json reviver that when encountering a number will decide whether that number needs to be
+ * represented as a bigint in order to be lossless. Uses normal numbers whenever possible or required.
+ * @param _key The key at which the value lives
+ * @param value The value that was read
+ * @param data Additional data, source includes the raw json value.
+ * @returns The javascript value
+ */
+export declare function bigintJsonNumberReviver(_key: string, value: any, data?: {
+    source?: string;
+}): any;
+//# sourceMappingURL=json.d.ts.map

package/lib/common/json.js

@@ -0,0 +1,53 @@
+/**
+ * Json replacer that writes bigints as a json string of the form `"$$type:bigint;$$value:91"`.
+ * Intended to be used with `bigintJsonLosslessReviver`
+ * @param _key The key at which the value lives
+ * @param value The value to encode
+ * @returns Replaced value
+ */
+export function bigintJsonLosslessReplacer(_key, value) {
+    return typeof value === 'bigint'
+        ? `$$type:bigint;$$value:${value}`
+        : value;
+}
+/**
+ * Json reviver that revives bigints encoded by `bigintJsonLosslessReplacer`
+ * @param _key
+ * @param value
+ * @returns
+ */
+export function bigintJsonLosslessReviver(_key, value) {
+    return typeof value === 'string' && value.startsWith('$$type:bigint;$$value:')
+        ? BigInt(value.substring(22))
+        : value;
+}
+/**
+ * Json replacer that replaces bigints with raw json number literals, encoding the entire number.
+ * @param _key The key at which the value lives
+ * @param value The value to encode
+ * @returns Replaced value
+ */
+export function bigintJsonNumberReplacer(_key, value) {
+    return typeof value === 'bigint'
+        ? JSON.rawJSON(value.toString())
+        : value;
+}
+/**
+ * Json reviver that when encountering a number will decide whether that number needs to be
+ * represented as a bigint in order to be lossless. Uses normal numbers whenever possible or required.
+ * @param _key The key at which the value lives
+ * @param value The value that was read
+ * @param data Additional data, source includes the raw json value.
+ * @returns The javascript value
+ */
+export function bigintJsonNumberReviver(_key, value, data) {
+    return typeof value === 'number'
+        && data?.source !== undefined
+        && !data.source.includes('.')
+        && !data.source.includes('e')
+        && !data.source.includes('E')
+        && BigInt(value).toString() !== data.source
+        ? BigInt(data.source)
+        : value;
+}
+//# sourceMappingURL=json.js.map

package/lib/common/util.d.ts

@@ -1,7 +1,6 @@
 import externalBinarySearch from 'binary-search';
 import type { AstNode } from '../node/index.js';
 import type { ProcessorContext } from '../service/index.js';
-import type { Externals } from './externals/index.js';
 import type { DeepReadonly, ReadWrite } from './ReadonlyProxy.js';
 export declare const Uri: {
     new (url: string | URL, base?: string | URL): URL;
@@ -77,7 +76,7 @@ export declare namespace TypePredicates {
     function isString(value: unknown): value is string;
 }
 export declare function promisifyAsyncIterable<T, U>(iterable: AsyncIterable<T>, joiner: (chunks: T[]) => U): Promise<U>;
-export declare function parseGzippedJson(externals: Externals, buffer: Uint8Array<ArrayBuffer>): Promise<unknown>;
+export declare function parseGzippedJson(bytes: Uint8Array<ArrayBuffer>): Promise<unknown>;
 /**
  * @returns Is Plain Old JavaScript Object (POJO).
  */
@@ -110,17 +109,25 @@ export declare namespace Lazy {
 export declare function getStates(category: 'block' | 'fluid', ids: readonly string[], ctx: ProcessorContext): Record<string, string[]>;
 export declare const binarySearch: typeof externalBinarySearch;
 export declare function isIterable(value: unknown): value is Iterable<unknown>;
-export declare function atArray<T>(array: readonly T[] | undefined, index: number): T | undefined;
-export declare function emplaceMap<K, V>(map: Map<K, V>, key: K, handler: {
-    insert?: (key: K, map: Map<K, V>) => V;
-    update?: (existing: V, key: K, map: Map<K, V>) => V;
-}): V;
+export declare function getOrInsert<K, V>(map: Map<K, V>, key: K, defaultValue: V): V;
+export declare function getOrInsertComputed<K, V>(map: Map<K, V>, key: K, callbackFunction: (key: K) => V): V;
+/**
+ * TODO: replace with ESNext Uint8Array.prototype.toHex once it's widely supported
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
 /**
  * @returns If `val` is an non-null object or a callable object (i.e. function).
  */
 export declare function isObject(val: unknown): val is object;
 export declare function normalizeUriPathname(pathname: string): string;
 export declare function normalizeUri(uri: string): string;
+export declare function getSha1(data: string | Uint8Array<ArrayBuffer>): Promise<string>;
+export declare function compressBytes(bytes: Uint8Array<ArrayBuffer>, algorithm: CompressionFormat): Promise<Uint8Array<ArrayBuffer>>;
+export declare function compressStream(stream: ReadableStream<Uint8Array<ArrayBuffer>>, algorithm: CompressionFormat): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function decompressBytes(bytes: Uint8Array<ArrayBuffer>, algorithm: CompressionFormat): Promise<Uint8Array<ArrayBuffer>>;
+export declare function decompressStream(stream: ReadableStream<Uint8Array<ArrayBuffer>>, algorithm: CompressionFormat): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function bytesToStream(bytes: Uint8Array<ArrayBuffer>): ReadableStream<Uint8Array<ArrayBuffer>>;
+export declare function streamToBytes(stream: ReadableStream<Uint8Array<ArrayBuffer>>): Promise<Uint8Array<ArrayBuffer>>;
 /**
  * Return a read-write TARGET type if the INPUT type is read-write, and a
  * readonly TARGET type if the INPUT type is readonly, and `never` if the INPUT
@@ -141,4 +148,34 @@ export declare function normalizeUri(uri: string): string;
  * ```
  */
 export type InheritReadonly<TARGET extends AstNode, INPUT extends DeepReadonly<AstNode> | undefined> = INPUT & (INPUT extends ReadWrite<AstNode> ? TARGET : DeepReadonly<TARGET>);
+/**
+ * Checks if the numeric value of a number or bigint is the same. Undefined is **not** the same as
+ * 0 for this function.
+ * @param a The first number to compare
+ * @param b The second number to compare
+ * @returns True if the numeric falue is equal, false otherwise.
+ */
+export declare function numericEquals(a: bigint | number | undefined, b: bigint | number | undefined): boolean;
+/**
+ * Tries to convert a numeric type to number if that is possible without precision loss.
+ * Undefined stays untouched.
+ * @param n The numeric value
+ * @returns The numeric value converted to a number if there was no precision loss, the given value
+ * otherwise
+ */
+export declare function tryConvertToNumberWithoutPrecisionLoss<T extends (number | bigint | undefined)>(n: T): number | T;
+/**
+ * Compares two numeric types and finds the smallest
+ * @param a The first value
+ * @param b The second value
+ * @returns The smaller value of `a` and `b`
+ */
+export declare function min<T extends (number | bigint)>(a: T, b: T): T;
+/**
+ * Compares two numeric types and finds the biggest
+ * @param a The first value
+ * @param b The second value
+ * @returns The bigger value of `a` and `b`
+ */
+export declare function max<T extends (number | bigint)>(a: T, b: T): T;
 //# sourceMappingURL=util.d.ts.map

package/lib/common/util.js

@@ -146,8 +146,8 @@ export function promisifyAsyncIterable(iterable, joiner) {
         return joiner(chunks);
     })();
 }
-export async function parseGzippedJson(externals, buffer) {
-    return JSON.parse(bufferToString(await externals.archive.gunzip(buffer)));
+export async function parseGzippedJson(bytes) {
+    return JSON.parse(bufferToString(await decompressBytes(bytes, 'gzip')));
 }
 /**
  * @returns Is Plain Old JavaScript Object (POJO).
@@ -218,26 +218,33 @@ export function isIterable(value) {
     return !!value[Symbol.iterator];
 }
 // #region ESNext functions polyfill
-export function atArray(array, index) {
-    return index >= 0 ? array?.[index] : array?.[array.length + index];
+export function getOrInsert(map, key, defaultValue) {
+    if (!map.has(key)) {
+        map.set(key, defaultValue);
+    }
+    return map.get(key);
 }
-export function emplaceMap(map, key, handler) {
-    if (map.has(key)) {
-        let value = map.get(key);
-        if (handler.update) {
-            value = handler.update(value, key, map);
-            map.set(key, value);
-        }
-        return value;
+export function getOrInsertComputed(map, key, callbackFunction) {
+    if (!map.has(key)) {
+        map.set(key, callbackFunction(key));
+    }
+    return map.get(key);
+}
+/**
+ * TODO: replace with ESNext Uint8Array.prototype.toHex once it's widely supported
+ */
+export function bytesToHex(bytes) {
+    if ('Buffer' in globalThis && bytes instanceof Buffer) {
+        return bytes.toString('hex');
     }
-    else if (handler.insert) {
-        const value = handler.insert(key, map);
-        map.set(key, value);
-        return value;
+    else if ('toHex' in Uint8Array.prototype && typeof Uint8Array.prototype.toHex === 'function') {
+        return Uint8Array.prototype.toHex.call(bytes);
     }
-    else {
-        throw new Error(`No key ${key} in map and no insert handler provided`);
+    let ans = '';
+    for (const v of bytes) {
+        ans += v.toString(16).padStart(2, '0');
     }
+    return ans;
 }
 // #endregion
 /**
@@ -267,4 +274,73 @@ export function normalizeUri(uri) {
     obj.pathname = normalizeUriPathname(obj.pathname);
     return obj.toString();
 }
+export async function getSha1(data) {
+    if (typeof data === 'string') {
+        data = new TextEncoder().encode(data);
+    }
+    const hash = await crypto.subtle.digest('SHA-1', data.buffer);
+    return bytesToHex(new Uint8Array(hash));
+}
+export function compressBytes(bytes, algorithm) {
+    return streamToBytes(compressStream(bytesToStream(bytes), algorithm));
+}
+export function compressStream(stream, algorithm) {
+    return stream.pipeThrough(new CompressionStream(algorithm));
+}
+export function decompressBytes(bytes, algorithm) {
+    return streamToBytes(decompressStream(bytesToStream(bytes), algorithm));
+}
+export function decompressStream(stream, algorithm) {
+    return stream.pipeThrough(new DecompressionStream(algorithm));
+}
+export function bytesToStream(bytes) {
+    return new Blob([bytes]).stream();
+}
+export function streamToBytes(stream) {
+    return new Response(stream).bytes();
+}
+/**
+ * Checks if the numeric value of a number or bigint is the same. Undefined is **not** the same as
+ * 0 for this function.
+ * @param a The first number to compare
+ * @param b The second number to compare
+ * @returns True if the numeric falue is equal, false otherwise.
+ */
+export function numericEquals(a, b) {
+    return tryConvertToNumberWithoutPrecisionLoss(a) === tryConvertToNumberWithoutPrecisionLoss(b);
+}
+/**
+ * Tries to convert a numeric type to number if that is possible without precision loss.
+ * Undefined stays untouched.
+ * @param n The numeric value
+ * @returns The numeric value converted to a number if there was no precision loss, the given value
+ * otherwise
+ */
+export function tryConvertToNumberWithoutPrecisionLoss(n) {
+    if (typeof n === 'bigint') {
+        const num = Number(n);
+        if (BigInt(num) === n) {
+            return num;
+        }
+    }
+    return n;
+}
+/**
+ * Compares two numeric types and finds the smallest
+ * @param a The first value
+ * @param b The second value
+ * @returns The smaller value of `a` and `b`
+ */
+export function min(a, b) {
+    return a < b ? a : b;
+}
+/**
+ * Compares two numeric types and finds the biggest
+ * @param a The first value
+ * @param b The second value
+ * @returns The bigger value of `a` and `b`
+ */
+export function max(a, b) {
+    return a > b ? a : b;
+}
 //# sourceMappingURL=util.js.map

package/lib/node/StringNode.d.ts

@@ -2,7 +2,7 @@ import type { Parser } from '../parser/index.js';
 import type { ColorTokenType } from '../processor/index.js';
 import type { IndexMap, RangeLike } from '../source/index.js';
 import type { AstNode } from './AstNode.js';
-export declare const EscapeChars: readonly ["\"", "'", "\\", "b", "f", "n", "r", "s", "t"];
+export declare const EscapeChars: readonly ['"', "'", '\\', 'b', 'f', 'n', 'r', 's', 't'];
 export type EscapeChar = (typeof EscapeChars)[number];
 export declare namespace EscapeChar {
     function is(expected: EscapeChar[] | undefined, c: string): c is EscapeChar;