@json-eval-rs/webcore 0.0.54 → 0.0.56

package/dist/index.d.ts

@@ -10,6 +10,15 @@
  * @returns Version string
  */
 export declare function getVersion(wasmModule: any): string;
+/**
+ * Item for get schema value array results
+ */
+export interface SchemaValueItem {
+    /** Dotted path (e.g., "field1.field2") */
+    path: string;
+    /** Value at this path */
+    value: any;
+}
 /**
  * Return format for path-based methods
  */
@@ -372,11 +381,21 @@ export declare class JSONEvalCore {
      * @returns New instance
      */
     static fromCache(wasmModule: any, cacheKey: string, context?: any, data?: any): JSONEvalCore;
+    /**
+     * Evaluate logic expression without creating an instance
+     *
+     * @param wasmModule - WASM module
+     * @param logicStr - JSON Logic expression (string or object)
+     * @param data - Optional data (string or object)
+     * @param context - Optional context (string or object)
+     * @returns Evaluation result
+     */
+    static evaluateLogic(wasmModule: any, logicStr: string | object, data?: any, context?: any): any;
     /**
      * Validate data against schema (returns parsed JavaScript object)
      * Uses validateJS for Worker-safe serialization
      */
-    validate({ data, context }: ValidateOptions): Promise<ValidationResult>;
+    validate({ data, context, }: ValidateOptions): Promise<ValidationResult>;
     /**
      * Evaluate schema with data (returns parsed JavaScript object)
      */
@@ -384,32 +403,42 @@ export declare class JSONEvalCore {
     /**
      * Evaluate dependent fields (returns parsed JavaScript object, processes transitively)
      */
-    evaluateDependents({ changedPaths, data, context, reEvaluate }: EvaluateDependentsOptions): Promise<DependentChange[]>;
+    evaluateDependents({ changedPaths, data, context, reEvaluate, }: EvaluateDependentsOptions): Promise<DependentChange[]>;
     /**
      * Get evaluated schema
      */
-    getEvaluatedSchema({ skipLayout }?: GetEvaluatedSchemaOptions): Promise<any>;
+    getEvaluatedSchema({ skipLayout, }?: GetEvaluatedSchemaOptions): Promise<any>;
     /**
      * Get evaluated schema as MessagePack binary data
      */
-    getEvaluatedSchemaMsgpack({ skipLayout }?: GetEvaluatedSchemaOptions): Promise<Uint8Array>;
+    getEvaluatedSchemaMsgpack({ skipLayout, }?: GetEvaluatedSchemaOptions): Promise<Uint8Array>;
     /**
      * Get schema values (evaluations ending with .value)
      */
     getSchemaValue(): Promise<any>;
+    /**
+     * Get all schema values as array of path-value pairs
+     * Returns [{path: "", value: ""}, ...]
+     */
+    getSchemaValueArray(): Promise<SchemaValueItem[]>;
+    /**
+     * Get all schema values as object with dotted path keys
+     * Returns {path: value, ...}
+     */
+    getSchemaValueObject(): Promise<Record<string, any>>;
     /**
      * Get evaluated schema without $params field
      */
-    getEvaluatedSchemaWithoutParams({ skipLayout }?: GetEvaluatedSchemaOptions): Promise<any>;
+    getEvaluatedSchemaWithoutParams({ skipLayout, }?: GetEvaluatedSchemaOptions): Promise<any>;
     /**
      * Get a value from the evaluated schema using dotted path notation
      */
-    getEvaluatedSchemaByPath({ path, skipLayout }: GetValueByPathOptions): Promise<any | null>;
+    getEvaluatedSchemaByPath({ path, skipLayout, }: GetValueByPathOptions): Promise<any | null>;
     /**
      * Get values from the evaluated schema using multiple dotted path notations
      * Returns data in the specified format (skips paths that are not found)
      */
-    getEvaluatedSchemaByPaths({ paths, skipLayout, format }: GetValueByPathsOptions): Promise<any>;
+    getEvaluatedSchemaByPaths({ paths, skipLayout, format, }: GetValueByPathsOptions): Promise<any>;
     /**
      * Get a value from the schema using dotted path notation
      */
@@ -418,11 +447,11 @@ export declare class JSONEvalCore {
      * Get values from the schema using multiple dotted path notations
      * Returns data in the specified format (skips paths that are not found)
      */
-    getSchemaByPaths({ paths, format }: GetSchemaByPathsOptions): Promise<any>;
+    getSchemaByPaths({ paths, format, }: GetSchemaByPathsOptions): Promise<any>;
     /**
      * Reload schema with new data
      */
-    reloadSchema({ schema, context, data }: ReloadSchemaOptions): Promise<void>;
+    reloadSchema({ schema, context, data, }: ReloadSchemaOptions): Promise<void>;
     /**
      * Reload schema from MessagePack bytes
      */
@@ -471,7 +500,7 @@ export declare class JSONEvalCore {
     /**
      * Compile and run JSON logic from a JSON logic string
      */
-    compileAndRunLogic({ logicStr, data, context }: CompileAndRunLogicOptions): Promise<any>;
+    compileAndRunLogic({ logicStr, data, context, }: CompileAndRunLogicOptions): Promise<any>;
     /**
      * Compile JSON logic and return a global ID
      */
@@ -483,7 +512,7 @@ export declare class JSONEvalCore {
     /**
      * Validate data against schema rules with optional path filtering
      */
-    validatePaths({ data, context, paths }: EvaluateOptions): Promise<ValidationResult>;
+    validatePaths({ data, context, paths, }: EvaluateOptions): Promise<ValidationResult>;
     /**
      * Cancel any running evaluation
      */
@@ -491,40 +520,51 @@ export declare class JSONEvalCore {
     /**
      * Evaluate a subform with data
      */
-    evaluateSubform({ subformPath, data, context, paths }: EvaluateSubformOptions): Promise<void>;
+    evaluateSubform({ subformPath, data, context, paths, }: EvaluateSubformOptions): Promise<void>;
     /**
      * Validate subform data against its schema rules
      */
-    validateSubform({ subformPath, data, context }: ValidateSubformOptions): Promise<ValidationResult>;
+    validateSubform({ subformPath, data, context, }: ValidateSubformOptions): Promise<ValidationResult>;
     /**
      * Evaluate dependent fields in subform
      */
-    evaluateDependentsSubform({ subformPath, changedPaths, data, context, reEvaluate }: EvaluateDependentsSubformOptions): Promise<DependentChange[]>;
+    evaluateDependentsSubform({ subformPath, changedPaths, data, context, reEvaluate, }: EvaluateDependentsSubformOptions): Promise<DependentChange[]>;
     /**
      * Resolve layout for subform
      */
-    resolveLayoutSubform({ subformPath, evaluate }: ResolveLayoutSubformOptions): Promise<void>;
+    resolveLayoutSubform({ subformPath, evaluate, }: ResolveLayoutSubformOptions): Promise<void>;
     /**
      * Get evaluated schema from subform
      */
-    getEvaluatedSchemaSubform({ subformPath, resolveLayout }: GetEvaluatedSchemaSubformOptions): Promise<any>;
+    getEvaluatedSchemaSubform({ subformPath, resolveLayout, }: GetEvaluatedSchemaSubformOptions): Promise<any>;
+    /**
+     * Get schema value from subform in nested object format (all .value fields).
+     * Returns a hierarchical object structure mimicking the schema.
+     */
+    getSchemaValueSubform({ subformPath, }: GetSchemaValueSubformOptions): Promise<any>;
+    /**
+     * Get schema values from subform as a flat array of path-value pairs.
+     * Returns an array like `[{path: "field.sub", value: 123}, ...]`.
+     */
+    getSchemaValueArraySubform({ subformPath, }: GetSchemaValueSubformOptions): Promise<SchemaValueItem[]>;
     /**
-     * Get schema value from subform (all .value fields)
+     * Get schema values from subform as a flat object with dotted path keys.
+     * Returns an object like `{"field.sub": 123, ...}`.
      */
-    getSchemaValueSubform({ subformPath }: GetSchemaValueSubformOptions): Promise<any>;
+    getSchemaValueObjectSubform({ subformPath, }: GetSchemaValueSubformOptions): Promise<Record<string, any>>;
     /**
      * Get evaluated schema without $params from subform
      */
-    getEvaluatedSchemaWithoutParamsSubform({ subformPath, resolveLayout }: GetEvaluatedSchemaSubformOptions): Promise<any>;
+    getEvaluatedSchemaWithoutParamsSubform({ subformPath, resolveLayout, }: GetEvaluatedSchemaSubformOptions): Promise<any>;
     /**
      * Get evaluated schema by specific path from subform
      */
-    getEvaluatedSchemaByPathSubform({ subformPath, schemaPath, skipLayout }: GetEvaluatedSchemaByPathSubformOptions): Promise<any | null>;
+    getEvaluatedSchemaByPathSubform({ subformPath, schemaPath, skipLayout, }: GetEvaluatedSchemaByPathSubformOptions): Promise<any | null>;
     /**
      * Get evaluated schema by multiple paths from subform
      * Returns data in the specified format (skips paths that are not found)
      */
-    getEvaluatedSchemaByPathsSubform({ subformPath, schemaPaths, skipLayout, format }: GetEvaluatedSchemaByPathsSubformOptions): Promise<any>;
+    getEvaluatedSchemaByPathsSubform({ subformPath, schemaPaths, skipLayout, format, }: GetEvaluatedSchemaByPathsSubformOptions): Promise<any>;
     /**
      * Get list of available subform paths
      */
@@ -532,12 +572,12 @@ export declare class JSONEvalCore {
     /**
      * Get schema by specific path from subform
      */
-    getSchemaByPathSubform({ subformPath, schemaPath }: GetSchemaByPathSubformOptions): Promise<any | null>;
+    getSchemaByPathSubform({ subformPath, schemaPath, }: GetSchemaByPathSubformOptions): Promise<any | null>;
     /**
      * Get schema by multiple paths from subform
      * Returns data in the specified format (skips paths that are not found)
      */
-    getSchemaByPathsSubform({ subformPath, schemaPaths, format }: GetSchemaByPathsSubformOptions): Promise<any>;
+    getSchemaByPathsSubform({ subformPath, schemaPaths, format, }: GetSchemaByPathsSubformOptions): Promise<any>;
     /**
      * Check if a subform exists at the given path
      */

package/dist/index.js

@@ -10,10 +10,10 @@
  * @returns Version string
  */
 export function getVersion(wasmModule) {
-    if (wasmModule && typeof wasmModule.getVersion === 'function') {
+    if (wasmModule && typeof wasmModule.getVersion === "function") {
         return wasmModule.getVersion();
     }
-    return 'unknown';
+    return "unknown";
 }
 /**
  * Return format for path-based methods
@@ -78,9 +78,9 @@ export class JSONEvalCore {
             return;
         // If WASM module not provided, throw error - user must provide it or install peer dependency
         if (!this._wasmModule) {
-            throw new Error('No WASM module provided. Please either:\n' +
+            throw new Error("No WASM module provided. Please either:\n" +
                 '1. Pass wasmModule in constructor: new JSONEval({ schema, wasmModule: await import("@json-eval-rs/bundler") })\n' +
-                '2. Or install a peer dependency: yarn install @json-eval-rs/bundler (or @json-eval-rs/vanilla or @json-eval-rs/node)');
+                "2. Or install a peer dependency: yarn install @json-eval-rs/bundler (or @json-eval-rs/vanilla or @json-eval-rs/node)");
         }
         try {
             const { JSONEvalWasm } = this._wasmModule;
@@ -116,14 +116,44 @@ export class JSONEvalCore {
             schema: cacheKey,
             context,
             data,
-            fromCache: true
+            fromCache: true,
         });
     }
+    /**
+     * Evaluate logic expression without creating an instance
+     *
+     * @param wasmModule - WASM module
+     * @param logicStr - JSON Logic expression (string or object)
+     * @param data - Optional data (string or object)
+     * @param context - Optional context (string or object)
+     * @returns Evaluation result
+     */
+    static evaluateLogic(wasmModule, logicStr, data, context) {
+        if (!wasmModule) {
+            throw new Error("No WASM module provided.");
+        }
+        const { JSONEvalWasm } = wasmModule;
+        if (!JSONEvalWasm || typeof JSONEvalWasm.evaluateLogic !== "function") {
+            throw new Error("WASM module does not support evaluateLogic.");
+        }
+        const logic = typeof logicStr === "string" ? logicStr : JSON.stringify(logicStr);
+        const dataStr = data
+            ? typeof data === "string"
+                ? data
+                : JSON.stringify(data)
+            : null;
+        const contextStr = context
+            ? typeof context === "string"
+                ? context
+                : JSON.stringify(context)
+            : null;
+        return JSONEvalWasm.evaluateLogic(logic, dataStr, contextStr);
+    }
     /**
      * Validate data against schema (returns parsed JavaScript object)
      * Uses validateJS for Worker-safe serialization
      */
-    async validate({ data, context }) {
+    async validate({ data, context, }) {
         await this.init();
         try {
             // Use validateJS for proper serialization (Worker-safe)
@@ -148,7 +178,7 @@ export class JSONEvalCore {
     /**
      * Evaluate dependent fields (returns parsed JavaScript object, processes transitively)
      */
-    async evaluateDependents({ changedPaths, data, context, reEvaluate = true }) {
+    async evaluateDependents({ changedPaths, data, context, reEvaluate = true, }) {
         await this.init();
         try {
             // Ensure paths is an array for WASM
@@ -162,14 +192,14 @@ export class JSONEvalCore {
     /**
      * Get evaluated schema
      */
-    async getEvaluatedSchema({ skipLayout = false } = {}) {
+    async getEvaluatedSchema({ skipLayout = false, } = {}) {
         await this.init();
         return this._instance.getEvaluatedSchemaJS(skipLayout);
     }
     /**
      * Get evaluated schema as MessagePack binary data
      */
-    async getEvaluatedSchemaMsgpack({ skipLayout = false } = {}) {
+    async getEvaluatedSchemaMsgpack({ skipLayout = false, } = {}) {
         await this.init();
         return this._instance.getEvaluatedSchemaMsgpack(skipLayout);
     }
@@ -180,17 +210,33 @@ export class JSONEvalCore {
         await this.init();
         return this._instance.getSchemaValue();
     }
+    /**
+     * Get all schema values as array of path-value pairs
+     * Returns [{path: "", value: ""}, ...]
+     */
+    async getSchemaValueArray() {
+        await this.init();
+        return this._instance.getSchemaValueArray();
+    }
+    /**
+     * Get all schema values as object with dotted path keys
+     * Returns {path: value, ...}
+     */
+    async getSchemaValueObject() {
+        await this.init();
+        return this._instance.getSchemaValueObject();
+    }
     /**
      * Get evaluated schema without $params field
      */
-    async getEvaluatedSchemaWithoutParams({ skipLayout = false } = {}) {
+    async getEvaluatedSchemaWithoutParams({ skipLayout = false, } = {}) {
         await this.init();
         return this._instance.getEvaluatedSchemaWithoutParamsJS(skipLayout);
     }
     /**
      * Get a value from the evaluated schema using dotted path notation
      */
-    async getEvaluatedSchemaByPath({ path, skipLayout = false }) {
+    async getEvaluatedSchemaByPath({ path, skipLayout = false, }) {
         await this.init();
         return this._instance.getEvaluatedSchemaByPathJS(path, skipLayout);
     }
@@ -198,7 +244,7 @@ export class JSONEvalCore {
      * Get values from the evaluated schema using multiple dotted path notations
      * Returns data in the specified format (skips paths that are not found)
      */
-    async getEvaluatedSchemaByPaths({ paths, skipLayout = false, format = 0 }) {
+    async getEvaluatedSchemaByPaths({ paths, skipLayout = false, format = 0, }) {
         await this.init();
         return this._instance.getEvaluatedSchemaByPathsJS(JSON.stringify(paths), skipLayout, format);
     }
@@ -213,16 +259,16 @@ export class JSONEvalCore {
      * Get values from the schema using multiple dotted path notations
      * Returns data in the specified format (skips paths that are not found)
      */
-    async getSchemaByPaths({ paths, format = 0 }) {
+    async getSchemaByPaths({ paths, format = 0, }) {
         await this.init();
         return this._instance.getSchemaByPathsJS(JSON.stringify(paths), format);
     }
     /**
      * Reload schema with new data
      */
-    async reloadSchema({ schema, context, data }) {
+    async reloadSchema({ schema, context, data, }) {
         if (!this._instance) {
-            throw new Error('Instance not initialized. Call init() first.');
+            throw new Error("Instance not initialized. Call init() first.");
         }
         try {
             await this._instance.reloadSchema(JSON.stringify(schema), context ? JSON.stringify(context) : null, data ? JSON.stringify(data) : null);
@@ -240,10 +286,10 @@ export class JSONEvalCore {
      */
     async reloadSchemaMsgpack(schemaMsgpack, context, data) {
         if (!this._instance) {
-            throw new Error('Instance not initialized. Call init() first.');
+            throw new Error("Instance not initialized. Call init() first.");
         }
         if (!(schemaMsgpack instanceof Uint8Array)) {
-            throw new Error('schemaMsgpack must be a Uint8Array');
+            throw new Error("schemaMsgpack must be a Uint8Array");
         }
         try {
             await this._instance.reloadSchemaMsgpack(schemaMsgpack, context ? JSON.stringify(context) : null, data ? JSON.stringify(data) : null);
@@ -262,10 +308,10 @@ export class JSONEvalCore {
      */
     async reloadSchemaFromCache(cacheKey, context, data) {
         if (!this._instance) {
-            throw new Error('Instance not initialized. Call init() first.');
+            throw new Error("Instance not initialized. Call init() first.");
         }
-        if (typeof cacheKey !== 'string' || !cacheKey) {
-            throw new Error('cacheKey must be a non-empty string');
+        if (typeof cacheKey !== "string" || !cacheKey) {
+            throw new Error("cacheKey must be a non-empty string");
         }
         try {
             await this._instance.reloadSchemaFromCache(cacheKey, context ? JSON.stringify(context) : null, data ? JSON.stringify(data) : null);
@@ -337,16 +383,16 @@ export class JSONEvalCore {
      */
     setTimezoneOffset(offsetMinutes) {
         if (!this._instance) {
-            throw new Error('Instance not initialized. Call init() first.');
+            throw new Error("Instance not initialized. Call init() first.");
         }
         this._instance.setTimezoneOffset(offsetMinutes);
     }
     /**
      * Compile and run JSON logic from a JSON logic string
      */
-    async compileAndRunLogic({ logicStr, data, context }) {
+    async compileAndRunLogic({ logicStr, data, context, }) {
         await this.init();
-        const logic = typeof logicStr === 'string' ? logicStr : JSON.stringify(logicStr);
+        const logic = typeof logicStr === "string" ? logicStr : JSON.stringify(logicStr);
         const result = await this._instance.compileAndRunLogic(logic, data ? JSON.stringify(data) : null, context ? JSON.stringify(context) : null);
         return result;
     }
@@ -355,7 +401,7 @@ export class JSONEvalCore {
      */
     async compileLogic(logicStr) {
         await this.init();
-        const logic = typeof logicStr === 'string' ? logicStr : JSON.stringify(logicStr);
+        const logic = typeof logicStr === "string" ? logicStr : JSON.stringify(logicStr);
         return this._instance.compileLogic(logic);
     }
     /**
@@ -369,7 +415,7 @@ export class JSONEvalCore {
     /**
      * Validate data against schema rules with optional path filtering
      */
-    async validatePaths({ data, context, paths }) {
+    async validatePaths({ data, context, paths, }) {
         await this.init();
         try {
             // Use validatePathsJS for proper serialization (Worker-safe)
@@ -393,21 +439,21 @@ export class JSONEvalCore {
     /**
      * Evaluate a subform with data
      */
-    async evaluateSubform({ subformPath, data, context, paths }) {
+    async evaluateSubform({ subformPath, data, context, paths, }) {
         await this.init();
         return this._instance.evaluateSubform(subformPath, JSON.stringify(data), context ? JSON.stringify(context) : null, paths || null);
     }
     /**
      * Validate subform data against its schema rules
      */
-    async validateSubform({ subformPath, data, context }) {
+    async validateSubform({ subformPath, data, context, }) {
         await this.init();
         return this._instance.validateSubform(subformPath, JSON.stringify(data), context ? JSON.stringify(context) : null);
     }
     /**
      * Evaluate dependent fields in subform
      */
-    async evaluateDependentsSubform({ subformPath, changedPaths, data, context, reEvaluate = true }) {
+    async evaluateDependentsSubform({ subformPath, changedPaths, data, context, reEvaluate = true, }) {
         await this.init();
         // For backward compatibility, accept single changedPath too (though types say array)
         const paths = Array.isArray(changedPaths) ? changedPaths : [changedPaths];
@@ -416,35 +462,52 @@ export class JSONEvalCore {
     /**
      * Resolve layout for subform
      */
-    async resolveLayoutSubform({ subformPath, evaluate = false }) {
+    async resolveLayoutSubform({ subformPath, evaluate = false, }) {
         await this.init();
         return this._instance.resolveLayoutSubform(subformPath, evaluate);
     }
     /**
      * Get evaluated schema from subform
      */
-    async getEvaluatedSchemaSubform({ subformPath, resolveLayout = false }) {
+    async getEvaluatedSchemaSubform({ subformPath, resolveLayout = false, }) {
         await this.init();
         return this._instance.getEvaluatedSchemaSubformJS(subformPath, resolveLayout);
     }
     /**
-     * Get schema value from subform (all .value fields)
+     * Get schema value from subform in nested object format (all .value fields).
+     * Returns a hierarchical object structure mimicking the schema.
      */
-    async getSchemaValueSubform({ subformPath }) {
+    async getSchemaValueSubform({ subformPath, }) {
         await this.init();
         return this._instance.getSchemaValueSubform(subformPath);
     }
+    /**
+     * Get schema values from subform as a flat array of path-value pairs.
+     * Returns an array like `[{path: "field.sub", value: 123}, ...]`.
+     */
+    async getSchemaValueArraySubform({ subformPath, }) {
+        await this.init();
+        return this._instance.getSchemaValueArraySubform(subformPath);
+    }
+    /**
+     * Get schema values from subform as a flat object with dotted path keys.
+     * Returns an object like `{"field.sub": 123, ...}`.
+     */
+    async getSchemaValueObjectSubform({ subformPath, }) {
+        await this.init();
+        return this._instance.getSchemaValueObjectSubform(subformPath);
+    }
     /**
      * Get evaluated schema without $params from subform
      */
-    async getEvaluatedSchemaWithoutParamsSubform({ subformPath, resolveLayout = false }) {
+    async getEvaluatedSchemaWithoutParamsSubform({ subformPath, resolveLayout = false, }) {
         await this.init();
         return this._instance.getEvaluatedSchemaWithoutParamsSubformJS(subformPath, resolveLayout);
     }
     /**
      * Get evaluated schema by specific path from subform
      */
-    async getEvaluatedSchemaByPathSubform({ subformPath, schemaPath, skipLayout = false }) {
+    async getEvaluatedSchemaByPathSubform({ subformPath, schemaPath, skipLayout = false, }) {
         await this.init();
         return this._instance.getEvaluatedSchemaByPathSubformJS(subformPath, schemaPath, skipLayout);
     }
@@ -452,7 +515,7 @@ export class JSONEvalCore {
      * Get evaluated schema by multiple paths from subform
      * Returns data in the specified format (skips paths that are not found)
      */
-    async getEvaluatedSchemaByPathsSubform({ subformPath, schemaPaths, skipLayout = false, format = 0 }) {
+    async getEvaluatedSchemaByPathsSubform({ subformPath, schemaPaths, skipLayout = false, format = 0, }) {
         await this.init();
         return this._instance.getEvaluatedSchemaByPathsSubformJS(subformPath, JSON.stringify(schemaPaths), skipLayout, format);
     }
@@ -466,7 +529,7 @@ export class JSONEvalCore {
     /**
      * Get schema by specific path from subform
      */
-    async getSchemaByPathSubform({ subformPath, schemaPath }) {
+    async getSchemaByPathSubform({ subformPath, schemaPath, }) {
         await this.init();
         return this._instance.getSchemaByPathSubformJS(subformPath, schemaPath);
     }
@@ -474,7 +537,7 @@ export class JSONEvalCore {
      * Get schema by multiple paths from subform
      * Returns data in the specified format (skips paths that are not found)
      */
-    async getSchemaByPathsSubform({ subformPath, schemaPaths, format = 0 }) {
+    async getSchemaByPathsSubform({ subformPath, schemaPaths, format = 0, }) {
         await this.init();
         return this._instance.getSchemaByPathsSubformJS(subformPath, JSON.stringify(schemaPaths), format);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-eval-rs/webcore",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "description": "JSON Eval RS core JavaScript wrapper (internal package - not published)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",