@firmer/mesh 0.0.10 → 0.0.12

package/dist/__vite-browser-external-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/dist/asm/index.d.ts

@@ -9,3 +9,4 @@ export * from '../schema';
 export * from '../system';
 export * from '../tool';
 export * from '../types';
+export * from '../uses';

package/dist/codec/buffer.d.ts

@@ -0,0 +1,98 @@
+export type BufferEncoding = 'utf8' | 'utf-8' | 'base64' | 'hex';
+/**
+ * Cross-platform Buffer implementation
+ * Compatible with Node.js Buffer API subset
+ * Works on browsers, Node.js, and mini-programs (WeChat, Alipay, etc.)
+ */
+export declare class Buffer extends Uint8Array {
+    /**
+     * Base64 character set
+     */
+    private static readonly BASE64_CHARS;
+    private static readonly BASE64_LOOKUP;
+    /**
+     * Create a Buffer from various input types
+     * @param value string, Uint8Array, ArrayBuffer, or array of bytes
+     * @param encodingOrOffset encoding type for string, or offset for array-like
+     * @param length length parameter
+     * @returns Buffer instance
+     */
+    static from(value: string, encoding?: BufferEncoding): Buffer;
+    static from(value: Uint8Array): Buffer;
+    static from(value: ArrayBuffer): Buffer;
+    static from(value: ArrayLike<number>): Buffer;
+    static from(value: Iterable<number>): Buffer;
+    /**
+     * Create a Buffer from a string with specified encoding
+     */
+    private static fromString;
+    /**
+     * Encode string to UTF-8 bytes
+     */
+    private static encodeUtf8;
+    /**
+     * Decode base64 string to bytes
+     */
+    private static decodeBase64;
+    /**
+     * Decode hex string to bytes
+     */
+    private static decodeHex;
+    /**
+     * Allocate a new Buffer of specified size
+     * @param size buffer size in bytes
+     * @param fill optional fill value
+     * @returns Buffer instance
+     */
+    static alloc(size: number, fill?: number | string, encoding?: BufferEncoding): Buffer;
+    /**
+     * Allocate an uninitialized Buffer
+     * @param size buffer size in bytes
+     * @returns Buffer instance
+     */
+    static allocUnsafe(size: number): Buffer;
+    /**
+     * Check if an object is a Buffer
+     */
+    static isBuffer(obj: any): obj is Buffer;
+    /**
+     * Concatenate multiple buffers
+     */
+    static concat(list: Uint8Array[], totalLength?: number): Buffer;
+    /**
+     * Compare two buffers
+     */
+    static compare(a: Uint8Array, b: Uint8Array): number;
+    /**
+     * Instance method: Convert Buffer to string with specified encoding
+     * @param encoding encoding type (base64, hex, utf8, etc.)
+     * @param start start index
+     * @param end end index
+     * @returns encoded string
+     */
+    toString(encoding?: BufferEncoding, start?: number, end?: number): string;
+    /**
+     * Decode UTF-8 bytes to string
+     */
+    private static decodeUtf8;
+    /**
+     * Encode bytes to base64 string
+     */
+    private static encodeBase64;
+    /**
+     * Encode bytes to hex string
+     */
+    private static encodeHex;
+    /**
+     * Instance method: Compare with another buffer
+     */
+    compare(target: Uint8Array): number;
+    /**
+     * Instance method: Check if buffer equals another buffer
+     */
+    equals(other: Uint8Array): boolean;
+    /**
+     * Instance method: Write string to buffer at specified offset
+     */
+    write(str: string, offset?: number, length?: number, encoding?: BufferEncoding): number;
+}

package/dist/codec/codec.d.ts

@@ -1,4 +1,6 @@
 import { Type } from '../macro';
+import { TextEncoder as TextEncoderX } from './text';
+import { Buffer as BufferX } from './buffer';
 export declare abstract class Codec {
     static JSON: string;
     static PROTOBUF: string;
@@ -41,3 +43,7 @@ export declare abstract class Codec {
      */
     abstract stringify<T>(buffer: Uint8Array): string;
 }
+declare const textEncoder: TextEncoderX;
+declare const textDecoder: TextDecoder;
+declare const buffer: typeof BufferX | BufferConstructor;
+export { textEncoder, textDecoder, buffer };

package/dist/codec/index.d.ts

@@ -1,2 +1,4 @@
 export * from './codec';
 export * from './json';
+export * from './text';
+export * from './buffer';

package/dist/codec/json.d.ts

@@ -1,8 +1,6 @@
 import { Type } from '../macro';
 import { Codec } from './codec';
 export declare class JSONCodec extends Codec {
-    private readonly encoder;
-    private readonly decoder;
     decode<T>(buffer: Uint8Array, type: Type<T>): T;
     decorateAny(type: Type<any>, dict: any): any;
     encode(value: any): Uint8Array;

package/dist/codec/text.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Cross-platform TextEncoder implementation
+ * Compatible with standard TextEncoder API
+ * Works on browsers, Node.js, and mini-programs (WeChat, Alipay, etc.)
+ */
+export declare class TextEncoder {
+    readonly encoding: string;
+    /**
+     * Encode string to Uint8Array using UTF-8 encoding
+     * @param input string to encode
+     * @returns UTF-8 encoded Uint8Array
+     */
+    encode(input?: string): Uint8Array;
+    /**
+     * Encode string into provided Uint8Array
+     * @param source string to encode
+     * @param destination target Uint8Array
+     * @returns object with read and written counts
+     */
+    encodeInto(source: string, destination: Uint8Array): {
+        read: number;
+        written: number;
+    };
+}
+/**
+ * Cross-platform TextDecoder implementation
+ * Compatible with standard TextDecoder API
+ * Works on browsers, Node.js, and mini-programs (WeChat, Alipay, etc.)
+ */
+export declare class TextDecoder {
+    readonly encoding: string;
+    readonly fatal: boolean;
+    readonly ignoreBOM: boolean;
+    constructor(encoding?: string, options?: {
+        fatal?: boolean;
+        ignoreBOM?: boolean;
+    });
+    /**
+     * Decode Uint8Array to string using UTF-8 decoding
+     * @param input Uint8Array to decode
+     * @returns decoded string
+     */
+    decode(input?: Uint8Array | ArrayBuffer): string;
+}