@aztec/bb.js 0.0.1-commit.5daedc8 → 0.0.1-commit.6230a0c

package/dest/node-cjs/cbind/schema_visitor.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Schema Visitor - Minimal abstraction over raw msgpack schema
+ *
+ * Philosophy:
+ *   - Keep raw schema structure
+ *   - Resolve type references into a graph
+ *   - No normalization - languages handle their own conventions
+ *   - Output is "compiled schema" with resolved types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaVisitor = void 0;
+/**
+ * SchemaVisitor - Walks raw msgpack schema and resolves references
+ */
+class SchemaVisitor {
+    structs = new Map();
+    responses = new Map();
+    visit(commandsSchema, responsesSchema) {
+        // Reset state
+        this.structs.clear();
+        this.responses.clear();
+        const commands = [];
+        // Schema format: ["named_union", [[name, schema], ...]]
+        const commandPairs = commandsSchema[1];
+        const responsePairs = responsesSchema[1];
+        // First, visit all response types (including ErrorResponse)
+        for (const [respName, respSchema] of responsePairs) {
+            if (typeof respSchema !== 'string') {
+                const respStruct = this.visitStruct(respName, respSchema);
+                this.responses.set(respName, respStruct);
+            }
+        }
+        // Visit all commands and pair with responses
+        for (let i = 0; i < commandPairs.length; i++) {
+            const [cmdName, cmdSchema] = commandPairs[i];
+            // Find matching response (skip ErrorResponse which is always last)
+            const normalResponses = responsePairs.filter(([name]) => name !== 'ErrorResponse');
+            const [respName] = normalResponses[i];
+            // Discover command structure
+            const cmdStruct = this.visitStruct(cmdName, cmdSchema);
+            this.structs.set(cmdName, cmdStruct);
+            // Create command mapping
+            commands.push({
+                name: cmdName,
+                fields: cmdStruct.fields,
+                responseType: respName,
+            });
+        }
+        return {
+            structs: this.structs,
+            commands,
+            responses: this.responses,
+        };
+    }
+    visitStruct(name, schema) {
+        const fields = [];
+        // Schema is an object with __typename and fields
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === '__typename')
+                continue;
+            fields.push({
+                name: key,
+                type: this.visitType(value),
+            });
+        }
+        return { name, fields };
+    }
+    visitType(schema) {
+        // Primitive string type
+        if (typeof schema === 'string') {
+            return this.resolvePrimitive(schema);
+        }
+        // Array type descriptor: ['vector', [elementType]]
+        if (Array.isArray(schema)) {
+            const [kind, args] = schema;
+            switch (kind) {
+                case 'vector': {
+                    const [elemType] = args;
+                    // Special case: vector<unsigned char> = bytes
+                    if (elemType === 'unsigned char') {
+                        return { kind: 'primitive', primitive: 'bytes' };
+                    }
+                    return {
+                        kind: 'vector',
+                        element: this.visitType(elemType),
+                    };
+                }
+                case 'array': {
+                    const [elemType, size] = args;
+                    // Special case: array<unsigned char, N> = bytes
+                    if (elemType === 'unsigned char') {
+                        return { kind: 'primitive', primitive: 'bytes' };
+                    }
+                    return {
+                        kind: 'array',
+                        element: this.visitType(elemType),
+                        size,
+                    };
+                }
+                case 'optional': {
+                    const [elemType] = args;
+                    return {
+                        kind: 'optional',
+                        element: this.visitType(elemType),
+                    };
+                }
+                case 'shared_ptr': {
+                    // Dereference shared_ptr - just use inner type
+                    const [innerType] = args;
+                    return this.visitType(innerType);
+                }
+                case 'alias': {
+                    // Alias types (like uint256_t) are treated as bytes
+                    return { kind: 'primitive', primitive: 'bytes' };
+                }
+                default:
+                    throw new Error(`Unknown type kind: ${kind}`);
+            }
+        }
+        // Inline struct definition
+        if (typeof schema === 'object' && schema.__typename) {
+            const structName = schema.__typename;
+            // Check if already visited
+            if (!this.structs.has(structName)) {
+                const struct = this.visitStruct(structName, schema);
+                this.structs.set(structName, struct);
+            }
+            return {
+                kind: 'struct',
+                struct: this.structs.get(structName),
+            };
+        }
+        throw new Error(`Cannot resolve type: ${JSON.stringify(schema)}`);
+    }
+    resolvePrimitive(name) {
+        const primitiveMap = {
+            'bool': 'bool',
+            'int': 'u32',
+            'unsigned int': 'u32',
+            'unsigned short': 'u16',
+            'unsigned long': 'u64',
+            'unsigned char': 'u8',
+            'double': 'f64',
+            'string': 'string',
+            'bin32': 'bytes',
+            'field2': 'field2', // Extension field (Fq2) - pair of field elements
+        };
+        const primitive = primitiveMap[name];
+        if (primitive) {
+            return { kind: 'primitive', primitive };
+        }
+        // Unknown primitive - treat as struct reference
+        // This will be resolved later if it's a real struct
+        return {
+            kind: 'struct',
+            struct: { name, fields: [] }, // Placeholder
+        };
+    }
+}
+exports.SchemaVisitor = SchemaVisitor;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node-cjs/cbind/typescript_codegen.d.ts

@@ -0,0 +1,30 @@
+/**
+ * TypeScript Code Generator - String template based
+ *
+ * Philosophy:
+ *   - String templates for file structure
+ *   - Simple type mapping
+ *   - Idiomatic TypeScript conventions
+ *   - No complex abstraction
+ */
+import type { CompiledSchema } from './schema_visitor.js';
+export declare class TypeScriptCodegen {
+    private mapType;
+    private mapMsgpackType;
+    private needsConversion;
+    private generateField;
+    private generateMsgpackField;
+    private generateInterface;
+    private generateMsgpackInterface;
+    private generateToFunction;
+    private generateFromFunction;
+    private generateToConverter;
+    private generateFromConverter;
+    generateTypes(schema: CompiledSchema): string;
+    private generateAsyncApiMethod;
+    private generateSyncApiMethod;
+    generateAsyncApi(schema: CompiledSchema): string;
+    generateSyncApi(schema: CompiledSchema): string;
+    private generateApiImports;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXNjcmlwdF9jb2RlZ2VuLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2JpbmQvdHlwZXNjcmlwdF9jb2RlZ2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFnQyxNQUFNLHFCQUFxQixDQUFDO0FBUXhGLHFCQUFhLGlCQUFpQjtJQUU1QixPQUFPLENBQUMsT0FBTztJQWlDZixPQUFPLENBQUMsY0FBYztJQWlDdEIsT0FBTyxDQUFDLGVBQWU7SUFldkIsT0FBTyxDQUFDLGFBQWE7SUFPckIsT0FBTyxDQUFDLG9CQUFvQjtJQU01QixPQUFPLENBQUMsaUJBQWlCO0lBVXpCLE9BQU8sQ0FBQyx3QkFBd0I7SUFVaEMsT0FBTyxDQUFDLGtCQUFrQjtJQThCMUIsT0FBTyxDQUFDLG9CQUFvQjtJQWlDNUIsT0FBTyxDQUFDLG1CQUFtQjtJQXdCM0IsT0FBTyxDQUFDLHFCQUFxQjtJQXdCN0IsYUFBYSxDQUFDLE1BQU0sRUFBRSxjQUFjLEdBQUcsTUFBTSxDQWlENUM7SUFHRCxPQUFPLENBQUMsc0JBQXNCO0lBbUI5QixPQUFPLENBQUMscUJBQXFCO0lBbUI3QixnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsY0FBYyxHQUFHLE1BQU0sQ0E2Qi9DO0lBR0QsZUFBZSxDQUFDLE1BQU0sRUFBRSxjQUFjLEdBQUcsTUFBTSxDQTZCOUM7SUFHRCxPQUFPLENBQUMsa0JBQWtCO0NBbUIzQiJ9

package/dest/node-cjs/cbind/typescript_codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript_codegen.d.ts","sourceRoot":"","sources":["../../../src/cbind/typescript_codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAgC,MAAM,qBAAqB,CAAC;AAQxF,qBAAa,iBAAiB;IAE5B,OAAO,CAAC,OAAO;IAiCf,OAAO,CAAC,cAAc;IAiCtB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,wBAAwB;IAUhC,OAAO,CAAC,kBAAkB;IA8B1B,OAAO,CAAC,oBAAoB;IAiC5B,OAAO,CAAC,mBAAmB;IAwB3B,OAAO,CAAC,qBAAqB;IAwB7B,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAiD5C;IAGD,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,qBAAqB;IAmB7B,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B/C;IAGD,eAAe,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B9C;IAGD,OAAO,CAAC,kBAAkB;CAmB3B"}

package/dest/node-cjs/cbind/typescript_codegen.js

@@ -0,0 +1,369 @@
+"use strict";
+/**
+ * TypeScript Code Generator - String template based
+ *
+ * Philosophy:
+ *   - String templates for file structure
+ *   - Simple type mapping
+ *   - Idiomatic TypeScript conventions
+ *   - No complex abstraction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptCodegen = void 0;
+const naming_js_1 = require("./naming.js");
+function toCamelCase(name) {
+    const pascal = (0, naming_js_1.toPascalCase)(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+class TypeScriptCodegen {
+    // Type mapping: Schema type -> TypeScript type
+    mapType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                switch (type.primitive) {
+                    case 'bool': return 'boolean';
+                    case 'u8': return 'number';
+                    case 'u16': return 'number';
+                    case 'u32': return 'number';
+                    case 'u64': return 'number';
+                    case 'f64': return 'number';
+                    case 'string': return 'string';
+                    case 'bytes': return 'Uint8Array';
+                    case 'field2': return '[Uint8Array, Uint8Array]'; // Extension field (Fq2)
+                }
+                break;
+            case 'vector':
+                return `${this.mapType(type.element)}[]`;
+            case 'array':
+                return `${this.mapType(type.element)}[]`;
+            case 'optional':
+                return `${this.mapType(type.element)} | undefined`;
+            case 'struct':
+                return (0, naming_js_1.toPascalCase)(type.struct.name);
+        }
+        return 'unknown';
+    }
+    // Type mapping for msgpack interfaces (uses Msgpack* prefix for structs)
+    mapMsgpackType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                switch (type.primitive) {
+                    case 'bool': return 'boolean';
+                    case 'u8': return 'number';
+                    case 'u16': return 'number';
+                    case 'u32': return 'number';
+                    case 'u64': return 'number';
+                    case 'f64': return 'number';
+                    case 'string': return 'string';
+                    case 'bytes': return 'Uint8Array';
+                    case 'field2': return '[Uint8Array, Uint8Array]';
+                }
+                break;
+            case 'vector':
+                return `${this.mapMsgpackType(type.element)}[]`;
+            case 'array':
+                return `${this.mapMsgpackType(type.element)}[]`;
+            case 'optional':
+                return `${this.mapMsgpackType(type.element)} | undefined`;
+            case 'struct':
+                return `Msgpack${(0, naming_js_1.toPascalCase)(type.struct.name)}`;
+        }
+        return 'unknown';
+    }
+    // Check if type needs conversion (has nested structs)
+    needsConversion(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return false;
+            case 'vector':
+            case 'array':
+            case 'optional':
+                return this.needsConversion(type.element);
+            case 'struct':
+                return true;
+        }
+        return false;
+    }
+    // Generate field
+    generateField(field) {
+        const tsName = toCamelCase(field.name);
+        const tsType = this.mapType(field.type);
+        return `  ${tsName}: ${tsType};`;
+    }
+    // Generate msgpack field (original names, uses Msgpack* types for structs)
+    generateMsgpackField(field) {
+        const tsType = this.mapMsgpackType(field.type);
+        return `  ${field.name}: ${tsType};`;
+    }
+    // Generate public interface
+    generateInterface(struct) {
+        const tsName = (0, naming_js_1.toPascalCase)(struct.name);
+        const fields = struct.fields.map(f => this.generateField(f)).join('\n');
+        return `export interface ${tsName} {
+${fields}
+}`;
+    }
+    // Generate msgpack interface (internal)
+    generateMsgpackInterface(struct) {
+        const tsName = (0, naming_js_1.toPascalCase)(struct.name);
+        const fields = struct.fields.map(f => this.generateMsgpackField(f)).join('\n');
+        return `interface Msgpack${tsName} {
+${fields}
+}`;
+    }
+    // Generate to* conversion function
+    generateToFunction(struct) {
+        const tsName = (0, naming_js_1.toPascalCase)(struct.name);
+        if (struct.fields.length === 0) {
+            return `function to${tsName}(o: Msgpack${tsName}): ${tsName} {
+  return {};
+}`;
+        }
+        const checks = struct.fields
+            .map(f => `  if (o.${f.name} === undefined) { throw new Error("Expected ${f.name} in ${tsName} deserialization"); }`)
+            .join('\n');
+        const conversions = struct.fields
+            .map(f => {
+            const tsFieldName = toCamelCase(f.name);
+            const converter = this.generateToConverter(f.type, `o.${f.name}`);
+            return `    ${tsFieldName}: ${converter},`;
+        })
+            .join('\n');
+        return `function to${tsName}(o: Msgpack${tsName}): ${tsName} {
+${checks};
+  return {
+${conversions}
+  };
+}`;
+    }
+    // Generate from* conversion function
+    generateFromFunction(struct) {
+        const tsName = (0, naming_js_1.toPascalCase)(struct.name);
+        if (struct.fields.length === 0) {
+            return `function from${tsName}(o: ${tsName}): Msgpack${tsName} {
+  return {};
+}`;
+        }
+        const checks = struct.fields
+            .map(f => {
+            const tsFieldName = toCamelCase(f.name);
+            return `  if (o.${tsFieldName} === undefined) { throw new Error("Expected ${tsFieldName} in ${tsName} serialization"); }`;
+        })
+            .join('\n');
+        const conversions = struct.fields
+            .map(f => {
+            const tsFieldName = toCamelCase(f.name);
+            const converter = this.generateFromConverter(f.type, `o.${tsFieldName}`);
+            return `  ${f.name}: ${converter},`;
+        })
+            .join('\n');
+        return `function from${tsName}(o: ${tsName}): Msgpack${tsName} {
+${checks};
+  return {
+${conversions}
+  };
+}`;
+    }
+    // Generate converter for to* function
+    generateToConverter(type, value) {
+        if (!this.needsConversion(type)) {
+            return value;
+        }
+        switch (type.kind) {
+            case 'vector':
+            case 'array':
+                if (this.needsConversion(type.element)) {
+                    return `${value}.map((v: any) => ${this.generateToConverter(type.element, 'v')})`;
+                }
+                return value;
+            case 'optional':
+                if (this.needsConversion(type.element)) {
+                    return `${value} !== undefined ? ${this.generateToConverter(type.element, value)} : undefined`;
+                }
+                return value;
+            case 'struct':
+                return `to${(0, naming_js_1.toPascalCase)(type.struct.name)}(${value})`;
+        }
+        return value;
+    }
+    // Generate converter for from* function
+    generateFromConverter(type, value) {
+        if (!this.needsConversion(type)) {
+            return value;
+        }
+        switch (type.kind) {
+            case 'vector':
+            case 'array':
+                if (this.needsConversion(type.element)) {
+                    return `${value}.map((v: any) => ${this.generateFromConverter(type.element, 'v')})`;
+                }
+                return value;
+            case 'optional':
+                if (this.needsConversion(type.element)) {
+                    return `${value} !== undefined ? ${this.generateFromConverter(type.element, value)} : undefined`;
+                }
+                return value;
+            case 'struct':
+                return `from${(0, naming_js_1.toPascalCase)(type.struct.name)}(${value})`;
+        }
+        return value;
+    }
+    // Generate types file (api_types.ts)
+    generateTypes(schema) {
+        const allStructs = [...schema.structs.values(), ...schema.responses.values()];
+        // Public interfaces
+        const publicInterfaces = allStructs
+            .map(s => this.generateInterface(s))
+            .join('\n\n');
+        // Msgpack interfaces
+        const msgpackInterfaces = allStructs
+            .map(s => this.generateMsgpackInterface(s))
+            .join('\n\n');
+        // Conversion functions
+        const toFunctions = allStructs
+            .map(s => 'export ' + this.generateToFunction(s))
+            .join('\n\n');
+        const fromFunctions = allStructs
+            .map(s => 'export ' + this.generateFromFunction(s))
+            .join('\n\n');
+        // BbApiBase interface
+        const apiMethods = schema.commands
+            .map(c => `  ${toCamelCase(c.name)}(command: ${(0, naming_js_1.toPascalCase)(c.name)}): Promise<${(0, naming_js_1.toPascalCase)(c.responseType)}>;`)
+            .join('\n');
+        return `// AUTOGENERATED FILE - DO NOT EDIT
+
+// Type aliases for primitive types
+export type Field2 = [Uint8Array, Uint8Array];
+
+// Public interfaces (exported)
+${publicInterfaces}
+
+// Private Msgpack interfaces (not exported)
+${msgpackInterfaces}
+
+// Conversion functions (exported)
+${toFunctions}
+
+${fromFunctions}
+
+// Base API interface
+export interface BbApiBase {
+${apiMethods}
+  destroy(): Promise<void>;
+}
+`;
+    }
+    // Generate API method
+    generateAsyncApiMethod(command) {
+        const methodName = toCamelCase(command.name);
+        const cmdType = (0, naming_js_1.toPascalCase)(command.name);
+        const respType = (0, naming_js_1.toPascalCase)(command.responseType);
+        return `  ${methodName}(command: ${cmdType}): Promise<${respType}> {
+    const msgpackCommand = from${cmdType}(command);
+    return msgpackCall(this.backend, [["${command.name}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
+      if (variantName === 'ErrorResponse') {
+        throw new BBApiException(result.message || 'Unknown error from barretenberg');
+      }
+      if (variantName !== '${command.responseType}') {
+        throw new BBApiException(\`Expected variant name '${command.responseType}' but got '\${variantName}'\`);
+      }
+      return to${respType}(result);
+    });
+  }`;
+    }
+    generateSyncApiMethod(command) {
+        const methodName = toCamelCase(command.name);
+        const cmdType = (0, naming_js_1.toPascalCase)(command.name);
+        const respType = (0, naming_js_1.toPascalCase)(command.responseType);
+        return `  ${methodName}(command: ${cmdType}): ${respType} {
+    const msgpackCommand = from${cmdType}(command);
+    const [variantName, result] = msgpackCall(this.backend, [["${command.name}", msgpackCommand]]);
+    if (variantName === 'ErrorResponse') {
+      throw new BBApiException(result.message || 'Unknown error from barretenberg');
+    }
+    if (variantName !== '${command.responseType}') {
+      throw new BBApiException(\`Expected variant name '${command.responseType}' but got '\${variantName}'\`);
+    }
+    return to${respType}(result);
+  }`;
+    }
+    // Generate async API file
+    generateAsyncApi(schema) {
+        const imports = this.generateApiImports(schema);
+        const methods = schema.commands
+            .map(c => this.generateAsyncApiMethod(c))
+            .join('\n\n');
+        return `// AUTOGENERATED FILE - DO NOT EDIT
+
+import { IMsgpackBackendAsync } from '../../bb_backends/interface.js';
+import { Decoder, Encoder } from 'msgpackr';
+import { BBApiException } from '../../bbapi_exception.js';
+${imports}
+
+async function msgpackCall(backend: IMsgpackBackendAsync, input: any[]) {
+  const inputBuffer = new Encoder({ useRecords: false }).pack(input);
+  const encodedResult = await backend.call(inputBuffer);
+  return new Decoder({ useRecords: false }).unpack(encodedResult);
+}
+
+export class AsyncApi implements BbApiBase {
+  constructor(protected backend: IMsgpackBackendAsync) {}
+
+${methods}
+
+  destroy(): Promise<void> {
+    return this.backend.destroy ? this.backend.destroy() : Promise.resolve();
+  }
+}
+`;
+    }
+    // Generate sync API file
+    generateSyncApi(schema) {
+        const imports = this.generateApiImports(schema);
+        const methods = schema.commands
+            .map(c => this.generateSyncApiMethod(c))
+            .join('\n\n');
+        return `// AUTOGENERATED FILE - DO NOT EDIT
+
+import { IMsgpackBackendSync } from '../../bb_backends/interface.js';
+import { Decoder, Encoder } from 'msgpackr';
+import { BBApiException } from '../../bbapi_exception.js';
+${imports}
+
+function msgpackCall(backend: IMsgpackBackendSync, input: any[]) {
+  const inputBuffer = new Encoder({ useRecords: false }).pack(input);
+  const encodedResult = backend.call(inputBuffer);
+  return new Decoder({ useRecords: false }).unpack(encodedResult);
+}
+
+export class SyncApi {
+  constructor(protected backend: IMsgpackBackendSync) {}
+
+${methods}
+
+  destroy(): void {
+    if (this.backend.destroy) this.backend.destroy();
+  }
+}
+`;
+    }
+    // Generate import statement for API files
+    generateApiImports(schema) {
+        const types = new Set();
+        // Add command types and their conversion functions
+        for (const cmd of schema.commands) {
+            const cmdType = (0, naming_js_1.toPascalCase)(cmd.name);
+            const respType = (0, naming_js_1.toPascalCase)(cmd.responseType);
+            types.add(cmdType);
+            types.add(respType);
+            types.add(`from${cmdType}`);
+            types.add(`to${respType}`);
+        }
+        // Add BbApiBase
+        types.add('BbApiBase');
+        const sortedTypes = Array.from(types).sort();
+        return `import { ${sortedTypes.join(', ')} } from './api_types.js';`;
+    }
+}
+exports.TypeScriptCodegen = TypeScriptCodegen;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript_codegen.js","sourceRoot":"","sources":["../../../src/cbind/typescript_codegen.ts"],"names":[],"mappings":"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"}

package/dest/node-cjs/crs/net_crs.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Fetches data from primary URL, falling back to secondary on failure
+ * @internal Exported for testing
+ */
+export declare function fetchWithFallback(primaryUrl: string, fallbackUrl: string, options: RequestInit): Promise<Response>;
 /**
  * Downloader for CRS from the web or local.
  */
@@ -67,4 +72,4 @@ export declare class NetGrumpkinCrs {
     getG1Data(): Uint8Array;
     private fetchG1Data;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0X2Nycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2Nycy9uZXRfY3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBOztHQUVHO0FBQ0gscUJBQWEsTUFBTTthQVFDLFNBQVMsRUFBRSxNQUFNO0lBUG5DLE9BQU8sQ0FBQyxJQUFJLENBQWM7SUFDMUIsT0FBTyxDQUFDLE1BQU0sQ0FBYztJQUU1QjtJQUNFOztPQUVHO0lBQ2EsU0FBUyxFQUFFLE1BQU0sRUFDL0I7SUFFSjs7T0FFRztJQUNHLElBQUksa0JBR1Q7SUFFRDs7T0FFRztJQUNHLFlBQVksSUFBSSxPQUFPLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBR3hEO0lBRUQ7O09BRUc7SUFDRyxZQUFZLElBQUksT0FBTyxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUd4RDtJQUVLLGNBQWMscUNBR25CO0lBRUQ7O09BRUc7SUFDRyxjQUFjLHFDQUduQjtJQUVEOzs7T0FHRztJQUNILFNBQVMsSUFBSSxVQUFVLENBRXRCO0lBRUQ7OztPQUdHO0lBQ0gsU0FBUyxJQUFJLFVBQVUsQ0FFdEI7WUFLYSxXQUFXO1lBc0JYLFdBQVc7Q0FTMUI7QUFFRDs7R0FFRztBQUNILHFCQUFhLGNBQWM7YUFPUCxTQUFTLEVBQUUsTUFBTTtJQU5uQyxPQUFPLENBQUMsSUFBSSxDQUFjO0lBRTFCO0lBQ0U7O09BRUc7SUFDYSxTQUFTLEVBQUUsTUFBTSxFQUMvQjtJQUVKOztPQUVHO0lBQ0csSUFBSSxrQkFFVDtJQUVLLGNBQWMscUNBR25CO0lBRUQ7O09BRUc7SUFDRyxZQUFZLElBQUksT0FBTyxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUd4RDtJQUVEOzs7T0FHRztJQUNILFNBQVMsSUFBSSxVQUFVLENBRXRCO1lBS2EsV0FBVztDQWUxQiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0X2Nycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2Nycy9uZXRfY3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BOzs7R0FHRztBQUNILHdCQUFzQixpQkFBaUIsQ0FDckMsVUFBVSxFQUFFLE1BQU0sRUFDbEIsV0FBVyxFQUFFLE1BQU0sRUFDbkIsT0FBTyxFQUFFLFdBQVcsR0FDbkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQVVuQjtBQUVEOztHQUVHO0FBQ0gscUJBQWEsTUFBTTthQVFDLFNBQVMsRUFBRSxNQUFNO0lBUG5DLE9BQU8sQ0FBQyxJQUFJLENBQWM7SUFDMUIsT0FBTyxDQUFDLE1BQU0sQ0FBYztJQUU1QjtJQUNFOztPQUVHO0lBQ2EsU0FBUyxFQUFFLE1BQU0sRUFDL0I7SUFFSjs7T0FFRztJQUNHLElBQUksa0JBR1Q7SUFFRDs7T0FFRztJQUNHLFlBQVksSUFBSSxPQUFPLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBR3hEO0lBRUQ7O09BRUc7SUFDRyxZQUFZLElBQUksT0FBTyxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUd4RDtJQUVLLGNBQWMscUNBR25CO0lBRUQ7O09BRUc7SUFDRyxjQUFjLHFDQUduQjtJQUVEOzs7T0FHRztJQUNILFNBQVMsSUFBSSxVQUFVLENBRXRCO0lBRUQ7OztPQUdHO0lBQ0gsU0FBUyxJQUFJLFVBQVUsQ0FFdEI7WUFLYSxXQUFXO1lBc0JYLFdBQVc7Q0FTMUI7QUFFRDs7R0FFRztBQUNILHFCQUFhLGNBQWM7YUFPUCxTQUFTLEVBQUUsTUFBTTtJQU5uQyxPQUFPLENBQUMsSUFBSSxDQUFjO0lBRTFCO0lBQ0U7O09BRUc7SUFDYSxTQUFTLEVBQUUsTUFBTSxFQUMvQjtJQUVKOztPQUVHO0lBQ0csSUFBSSxrQkFFVDtJQUVLLGNBQWMscUNBR25CO0lBRUQ7O09BRUc7SUFDRyxZQUFZLElBQUksT0FBTyxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUd4RDtJQUVEOzs7T0FHRztJQUNILFNBQVMsSUFBSSxVQUFVLENBRXRCO1lBS2EsV0FBVztDQW9CMUIifQ==

package/dest/node-cjs/crs/net_crs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"net_crs.d.ts","sourceRoot":"","sources":["../../../src/crs/net_crs.ts"],"names":[],"mappings":"AACA;;GAEG;AACH,qBAAa,MAAM;aAQC,SAAS,EAAE,MAAM;IAPnC,OAAO,CAAC,IAAI,CAAc;IAC1B,OAAO,CAAC,MAAM,CAAc;IAE5B;IACE;;OAEG;IACa,SAAS,EAAE,MAAM,EAC/B;IAEJ;;OAEG;IACG,IAAI,kBAGT;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAGxD;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAGxD;IAEK,cAAc,qCAGnB;IAED;;OAEG;IACG,cAAc,qCAGnB;IAED;;;OAGG;IACH,SAAS,IAAI,UAAU,CAEtB;IAED;;;OAGG;IACH,SAAS,IAAI,UAAU,CAEtB;YAKa,WAAW;YAsBX,WAAW;CAS1B;AAED;;GAEG;AACH,qBAAa,cAAc;aAOP,SAAS,EAAE,MAAM;IANnC,OAAO,CAAC,IAAI,CAAc;IAE1B;IACE;;OAEG;IACa,SAAS,EAAE,MAAM,EAC/B;IAEJ;;OAEG;IACG,IAAI,kBAET;IAEK,cAAc,qCAGnB;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAGxD;IAED;;;OAGG;IACH,SAAS,IAAI,UAAU,CAEtB;YAKa,WAAW;CAe1B"}
+{"version":3,"file":"net_crs.d.ts","sourceRoot":"","sources":["../../../src/crs/net_crs.ts"],"names":[],"mappings":"AAOA;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,QAAQ,CAAC,CAUnB;AAED;;GAEG;AACH,qBAAa,MAAM;aAQC,SAAS,EAAE,MAAM;IAPnC,OAAO,CAAC,IAAI,CAAc;IAC1B,OAAO,CAAC,MAAM,CAAc;IAE5B;IACE;;OAEG;IACa,SAAS,EAAE,MAAM,EAC/B;IAEJ;;OAEG;IACG,IAAI,kBAGT;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAGxD;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAGxD;IAEK,cAAc,qCAGnB;IAED;;OAEG;IACG,cAAc,qCAGnB;IAED;;;OAGG;IACH,SAAS,IAAI,UAAU,CAEtB;IAED;;;OAGG;IACH,SAAS,IAAI,UAAU,CAEtB;YAKa,WAAW;YAsBX,WAAW;CAS1B;AAED;;GAEG;AACH,qBAAa,cAAc;aAOP,SAAS,EAAE,MAAM;IANnC,OAAO,CAAC,IAAI,CAAc;IAE1B;IACE;;OAEG;IACa,SAAS,EAAE,MAAM,EAC/B;IAEJ;;OAEG;IACG,IAAI,kBAET;IAEK,cAAc,qCAGnB;IAED;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAGxD;IAED;;;OAGG;IACH,SAAS,IAAI,UAAU,CAEtB;YAKa,WAAW;CAoB1B"}