@calcit/procs 0.12.46 → 0.12.48

package/lib/calcit.procs.d.mts

@@ -0,0 +1,306 @@
+export declare const calcit_version: string;
+export declare const calcit_package_json: {
+    name: string;
+    version: string;
+    main: string;
+    devDependencies: {
+        "@types/node": string;
+        typescript: string;
+    };
+    scripts: {
+        compile: string;
+        "procs-link": string;
+        "cp-mac": string;
+        eval: string;
+        "fmt-rs": string;
+        "lint-rs": string;
+        "test-rs": string;
+        "test-fail": string;
+        "test-snippets": string;
+        "bench-recur-smoke": string;
+        "check-smooth": string;
+        "check-all": string;
+        "try-all": string;
+        "try-rs": string;
+        "warn-dyn-method": string;
+        "try-js-brk": string;
+        "try-js": string;
+        "try-ir": string;
+        "try-wasm": string;
+    };
+    repository: {
+        type: string;
+        url: string;
+    };
+    dependencies: {
+        "@calcit/ternary-tree": string;
+        "@cirru/parser.ts": string;
+        "@cirru/writer.ts": string;
+    };
+    packageManager: string;
+};
+import { ICirruNode } from "@cirru/parser.ts";
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitSymbol, CalcitTag, CalcitFn, CalcitRecur } from "./calcit-data.mjs";
+import { CalcitRef } from "./js-ref.mjs";
+import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
+import { CalcitStruct } from "./js-struct.mjs";
+import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitTrait } from "./js-trait.mjs";
+export * from "./calcit-data.mjs";
+export * from "./js-record.mjs";
+export * from "./js-impl.mjs";
+export * from "./js-struct.mjs";
+export * from "./js-enum.mjs";
+export * from "./js-map.mjs";
+export * from "./js-list.mjs";
+export * from "./js-set.mjs";
+export * from "./js-primes.mjs";
+export * from "./js-tuple.mjs";
+export * from "./js-trait.mjs";
+export * from "./custom-formatter.mjs";
+export * from "./js-cirru.mjs";
+export * from "./js-arity-helpers.mjs";
+export * from "./js-tag-helpers.mjs";
+export * from "./js-buf-list.mjs";
+export { _$n_compare } from "./js-primes.mjs";
+import { CalcitList, CalcitSliceList } from "./js-list.mjs";
+import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
+import { CalcitSet } from "./js-set.mjs";
+import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitCirruQuote } from "./js-cirru.mjs";
+export declare let type_of: (x: any) => CalcitTag;
+export declare let _$n_trait_$o__$o_new: (name: CalcitValue, methods: CalcitValue) => CalcitTrait;
+export declare let _$n_assert_traits: (value: CalcitValue, traitDef: CalcitValue) => CalcitValue;
+export declare let defstruct: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStruct;
+export declare let defenum: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnum;
+export declare let _$n_impl_$o__$o_new: (name: CalcitValue, ...pairs: CalcitValue[]) => CalcitImpl;
+export declare let _$n_struct_$o__$o_new: (name: CalcitValue, ...entries: CalcitValue[]) => CalcitStruct;
+export declare let _$n_enum_$o__$o_new: (name: CalcitValue, ...variants: CalcitValue[]) => CalcitEnum;
+export declare let print: (...xs: CalcitValue[]) => void;
+export declare function _$n_list_$o_count(x: CalcitValue): number;
+export declare function _$n_str_$o_count(x: CalcitValue): number;
+export declare function _$n_map_$o_count(x: CalcitValue): number;
+export declare function _$n_record_$o_count(x: CalcitValue): number;
+export declare function _$n_record_$o_field_tag(x: CalcitValue, idx: CalcitValue): CalcitTag;
+export declare function _$n_record_$o_nth(x: CalcitValue, idx: CalcitValue): CalcitValue;
+export declare function _$n_set_$o_count(x: CalcitValue): number;
+export declare let _$L_: (...xs: CalcitValue[]) => CalcitSliceList;
+export declare let _SQUO_: (...xs: CalcitValue[]) => CalcitSliceList;
+export declare let _$n__$M_: (...xs: CalcitValue[]) => CalcitSliceMap;
+export declare let defatom: (path: string, x: CalcitValue) => CalcitValue;
+export { atom } from "./js-ref.mjs";
+export declare let peekDefatom: (path: string) => CalcitRef;
+export declare let _$n_atom_$o_deref: (x: CalcitRef) => CalcitValue;
+export declare let _$n__ADD_: (x: number, y: number) => number;
+export declare let _$n__$s_: (x: number, y: number) => number;
+export declare let _$n_str: (x: CalcitValue) => string;
+export declare let _$n_str_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_list_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_map_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_record_$o_contains_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_str_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_list_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_map_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_set_$o_includes_$q_: (xs: CalcitValue, x: CalcitValue) => boolean;
+export declare let _$n_str_$o_nth: (xs: CalcitValue, k: CalcitValue) => string;
+export declare let _$n_list_$o_nth: (xs: CalcitValue, k: CalcitValue) => CalcitValue;
+export declare let _$n_tuple_$o_nth: (xs: CalcitValue, k: CalcitValue) => CalcitValue;
+export declare let _$n_tuple_$o_count: (xs: CalcitValue) => number;
+export declare let _$n_tuple_$o_impls: (x: CalcitTuple) => CalcitSliceList;
+export declare let _$n_tuple_$o_params: (x: CalcitTuple) => CalcitSliceList;
+export declare let _$n_tuple_$o_with_impls: (x: CalcitTuple, y: CalcitValue) => CalcitTuple;
+export declare let _$n_tuple_$o_impl_traits: (x: CalcitValue, ...traits: CalcitValue[]) => CalcitTuple;
+export declare let _$n_tuple_$o_enum: (x: CalcitTuple) => CalcitEnum;
+export declare let _$n_tuple_$o_enum_has_variant_$q_: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
+export declare let _$n_tuple_$o_enum_has_variant: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
+export declare let _$n_tuple_$o_enum_variant_arity: (enumPrototype: CalcitValue, variantTag: CalcitTag) => number;
+export declare let _$n_tuple_$o_validate_enum: (tuple: CalcitValue, tag: CalcitValue) => CalcitValue;
+export declare let _$n_record_$o_get: (xs: CalcitValue, k: CalcitTag) => CalcitValue;
+export declare let _$n_list_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitList;
+export declare let _$n_tuple_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitTuple;
+export declare let _$n_map_$o_assoc: (xs: CalcitValue, ...args: CalcitValue[]) => CalcitMap | CalcitSliceMap;
+export declare let _$n_record_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitRecord;
+export declare let _$n_record_$o_impls: (xs: CalcitValue) => CalcitSliceList;
+export declare let _$n_record_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitRecord;
+export declare let _$n_struct_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitStruct;
+export declare let _$n_enum_$o_impl_traits: (xs: CalcitValue, ...traits: CalcitValue[]) => CalcitRecord | CalcitEnum;
+export declare let _$n_impl_$o_origin: (impl: CalcitValue) => CalcitValue;
+export declare let _$n_impl_$o_get: (impl: CalcitValue, name: CalcitValue) => CalcitValue;
+export declare let _$n_impl_$o_nth: (impl: CalcitValue, index: CalcitValue) => CalcitValue;
+export declare let _$n_list_$o_assoc_before: (xs: CalcitList | CalcitSliceList, k: number, v: CalcitValue) => CalcitList;
+export declare let _$n_list_$o_assoc_after: (xs: CalcitSliceList, k: number, v: CalcitValue) => CalcitList | CalcitSliceList;
+export declare let _$n_list_$o_dissoc: (xs: CalcitValue | CalcitSliceList, k: CalcitValue) => CalcitList | CalcitSliceList;
+export declare let _$n_map_$o_dissoc: (xs: CalcitValue, ...args: CalcitValue[]) => CalcitMap | CalcitSliceMap;
+export declare let reset_$x_: (a: CalcitRef, v: CalcitValue) => null;
+export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => null;
+export declare let remove_watch: (a: CalcitRef, k: CalcitTag) => null;
+export declare let range: (n: number, m: number, step?: number) => CalcitSliceList | CalcitList;
+export declare function _$n_list_$o_empty_$q_(xs: CalcitValue): boolean;
+export declare function _$n_str_$o_empty_$q_(xs: CalcitValue): boolean;
+export declare function _$n_map_$o_empty_$q_(xs: CalcitValue): boolean;
+export declare function _$n_set_$o_empty_$q_(xs: CalcitValue): boolean;
+export declare let _$n_list_$o_first: (xs: CalcitValue) => CalcitValue;
+export declare let _$n_str_$o_first: (xs: CalcitValue) => CalcitValue;
+export declare let _$n_map_$o_destruct: (xs: CalcitValue) => CalcitValue;
+export declare let _$n_set_$o_destruct: (xs: CalcitValue) => CalcitValue;
+export declare let timeout_call: (duration: number, f: CalcitFn) => null;
+export declare let _$n_list_$o_rest: (xs: CalcitValue) => CalcitValue;
+export declare let _$n_str_$o_rest: (xs: CalcitValue) => CalcitValue;
+export declare let recur: (...xs: CalcitValue[]) => CalcitRecur;
+export declare let _$n_get_calcit_backend: () => CalcitTag;
+export declare let not: (x: boolean) => boolean;
+export declare let prepend: (xs: CalcitValue, v: CalcitValue) => CalcitList;
+export declare let append: (xs: CalcitValue, v: CalcitValue) => CalcitList | CalcitSliceList;
+export declare let last: (xs: CalcitValue) => CalcitValue;
+export declare let butlast: (xs: CalcitValue) => CalcitValue;
+export declare let initCrTernary: (x: string) => CalcitValue;
+export declare let _SHA__$M_: (...xs: CalcitValue[]) => CalcitValue;
+export declare let generate_id_$x_: () => string;
+export declare let _$n_display_stack: () => null;
+export declare let _$n_list_$o_slice: (xs: CalcitList, from: number, to: number) => CalcitSliceList | CalcitList;
+export declare let _$n_list_$o_concat: (...lists: (CalcitList | CalcitSliceList)[]) => CalcitList | CalcitSliceList;
+export declare let _$n_list_$o_reverse: (xs: CalcitList) => CalcitList;
+export declare let format_ternary_tree: () => null;
+export declare let _$n__GT_: (a: number, b: number) => boolean;
+export declare let _$n__LT_: (a: number, b: number) => boolean;
+export declare let _$n__: (a: number, b: number) => number;
+export declare let _$n__SLSH_: (a: number, b: number) => number;
+export declare let _$n_number_$o_rem: (a: number, b: number) => number;
+export declare let round_$q_: (a: number) => boolean;
+export declare let _$n_str_$o_concat: (a: string, b: string) => string;
+export declare let sort: (xs: CalcitList | CalcitSliceList, f: CalcitFn) => CalcitSliceList;
+export declare let floor: (n: number) => number;
+export declare let _$n_merge: (a: CalcitValue, b: CalcitMap | CalcitSliceMap) => CalcitValue;
+export declare let _$n_merge_non_nil: (a: CalcitMap | CalcitSliceMap, b: CalcitMap | CalcitSliceMap) => CalcitMap | CalcitSliceMap;
+export declare let to_pairs: (xs: CalcitValue) => CalcitValue | CalcitSliceList;
+export declare let sin: (n: number) => number;
+export declare let cos: (n: number) => number;
+export declare let pow: (n: number, m: number) => number;
+export declare let ceil: (n: number) => number;
+export declare let round: (n: number) => number;
+export declare let _$n_number_$o_fract: (n: number) => number;
+export declare let sqrt: (n: number) => number;
+export declare let _$n_include: (xs: CalcitSet, y: CalcitValue) => CalcitSet;
+export declare let _$n_exclude: (xs: CalcitSet, y: CalcitValue) => CalcitSet;
+export declare let _$n_difference: (xs: CalcitSet, ys: CalcitSet) => CalcitSet;
+export declare let _$n_union: (xs: CalcitSet, ys: CalcitSet) => CalcitSet;
+export declare let _$n_set_$o_intersection: (xs: CalcitSet, ys: CalcitSet) => CalcitSet;
+export declare let _$n_str_$o_replace: (x: string, y: string, z: string) => string;
+export declare let split: (xs: string, x: string) => CalcitSliceList;
+export declare let split_lines: (xs: string) => CalcitSliceList;
+export declare let _$n_str_$o_slice: (xs: string, m: number, n: number) => string;
+export declare let _$n_str_$o_find_index: (x: string, y: string) => number;
+export declare let parse_float: (x: string) => number | null;
+export declare let trim: (x: string, c: string) => string;
+export declare let _$n_number_$o_format: (x: number, n: number) => string;
+export declare let _$n_number_$o_display_by: (x: number, n: number) => string;
+export declare let get_char_code: (c: string) => number;
+export declare let char_from_code: (n: number) => string;
+export declare let _$n_set_$o_to_list: (x: CalcitSet) => CalcitSliceList;
+export declare let aget: (x: any, name: string) => any;
+export declare let aset: (x: any, name: string, v: any) => any;
+export declare let js_get: (x: any, name: string) => any;
+export declare let js_set: (x: any, name: string, v: any) => any;
+/** generates `delete a.b` */
+export declare let js_delete: (obj: any, name: string) => any;
+export declare let get_env: (name: string, v0: string) => string;
+export declare let turn_tag: (x: CalcitValue) => CalcitTag;
+export declare let turn_symbol: (x: CalcitValue) => CalcitSymbol;
+export declare let to_lispy_string: (...args: CalcitValue[]) => string;
+/** helper function for println, js only */
+export declare let printable: (...args: CalcitValue[]) => string;
+export declare let cpu_time: () => number;
+export declare let quit_$x_: () => void;
+export declare let turn_string: (x: CalcitValue) => string;
+export declare let identical_$q_: (x: CalcitValue, y: CalcitValue) => boolean;
+export declare let starts_with_$q_: (xs: CalcitValue, y: CalcitValue) => boolean;
+export declare let ends_with_$q_: (xs: string, y: string) => boolean;
+export declare let blank_$q_: (x: string) => boolean;
+export declare let _$n_str_$o_compare: (x: string, y: string) => 0 | 1 | -1;
+export declare let arrayToList: (xs: Array<CalcitValue>) => CalcitSliceList;
+export declare let listToArray: (xs: CalcitList | CalcitSliceList) => Array<CalcitValue>;
+export declare let number_$q_: (x: CalcitValue) => boolean;
+export declare let string_$q_: (x: CalcitValue) => boolean;
+export declare let bool_$q_: (x: CalcitValue) => boolean;
+export declare let nil_$q_: (x: CalcitValue) => boolean;
+export declare let tag_$q_: (x: CalcitValue) => boolean;
+export declare let symbol_$q_: (x: CalcitValue) => boolean;
+export declare let map_$q_: (x: CalcitValue) => boolean;
+export declare let list_$q_: (x: CalcitValue) => boolean;
+export declare let set_$q_: (x: CalcitValue) => boolean;
+export declare let fn_$q_: (x: CalcitValue) => boolean;
+export declare let ref_$q_: (x: CalcitValue) => boolean;
+export declare let record_$q_: (x: CalcitValue) => boolean;
+export declare let tuple_$q_: (x: CalcitValue) => boolean;
+export declare let buffer_$q_: (x: CalcitValue) => boolean;
+export declare let _$n_str_$o_escape: (x: string) => string;
+export declare let read_file: (path: string) => string;
+export declare let write_file: (path: string, content: string) => void;
+export declare let parse_cirru: (code: string) => CalcitCirruQuote;
+export declare let parse_cirru_list: (code: string) => CalcitList;
+export declare let parse_cirru_edn: (code: string, options: CalcitValue) => CalcitValue;
+export declare let json_parse: (code: CalcitValue) => CalcitValue;
+export declare let json_stringify: (value: CalcitValue) => string;
+export declare let json_pretty: (value: CalcitValue) => string;
+export declare let format_to_lisp: (x: CalcitValue) => string;
+export declare let format_to_cirru: (x: CalcitValue) => string;
+export declare let transform_code_to_cirru: (x: CalcitValue) => ICirruNode;
+/** for quickly creating js Array */
+export declare let js_array: (...xs: CalcitValue[]) => CalcitValue[];
+/** for..await alternative with function */
+export declare let js_for_await: (stream: AsyncIterableIterator<CalcitValue>, f: (v: CalcitValue) => Promise<CalcitValue>) => Promise<CalcitValue>;
+export declare let _$n_js_object: (...xs: CalcitValue[]) => Record<string, CalcitValue>;
+export declare let _$o__$o_: (tagName: CalcitValue, ...extra: CalcitValue[]) => CalcitTuple;
+export declare let _PCT__$o__$o_: (enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]) => CalcitTuple;
+export declare let _PCT__PCT__$o__$o_: (impl: CalcitValue, enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]) => CalcitTuple;
+type CalcitImplEntry = CalcitImpl | CalcitList | CalcitSliceList | null;
+declare let calcit_builtin_impls: {
+    number: CalcitImplEntry;
+    string: CalcitImplEntry;
+    set: CalcitImplEntry;
+    list: CalcitImplEntry;
+    map: CalcitImplEntry;
+    fn: CalcitImplEntry;
+    tuple: CalcitImplEntry;
+    record: CalcitImplEntry;
+};
+export declare let register_calcit_builtin_impls: (options: typeof calcit_builtin_impls) => void;
+/** method used as closure */
+export declare function invoke_method_closure(p: string): (obj: CalcitValue, ...args: CalcitValue[]) => CalcitValue;
+export declare function invoke_method(p: string, obj: CalcitValue, ...args: CalcitValue[]): CalcitValue;
+export declare function _$n_methods_of(obj: CalcitValue): CalcitSliceList;
+export declare function _$n_inspect_methods(obj: CalcitValue, note: CalcitValue): CalcitValue;
+export declare function _$n_trait_call(traitDef: CalcitValue, method: CalcitValue, obj: CalcitValue, ...args: CalcitValue[]): CalcitValue;
+export declare let _$n_map_$o_to_list: (m: CalcitValue) => CalcitSliceList;
+export declare let _$n_map_$o_diff_new: (a: CalcitValue, b: CalcitValue) => CalcitMap;
+export declare let _$n_map_$o_diff_keys: (a: CalcitValue, b: CalcitValue) => CalcitSet;
+export declare let _$n_map_$o_common_keys: (a: CalcitValue, b: CalcitValue) => CalcitSet;
+/** Single-pass diff: returns [drop-keys, new-diff, common-triples] in two traversals instead of 3+ */
+export declare let _$n_map_$o_diff_triple: (a: CalcitValue, b: CalcitValue) => CalcitSliceList;
+export declare let bit_shr: (base: number, step: number) => number;
+export declare let bit_shl: (base: number, step: number) => number;
+export declare let bit_and: (a: number, b: number) => number;
+export declare let bit_or: (a: number, b: number) => number;
+export declare let bit_xor: (a: number, b: number) => number;
+export declare let bit_not: (a: number) => number;
+export declare let _$n_list_$o_to_set: (xs: CalcitList) => CalcitSet;
+export declare let _$n_list_$o_distinct: (xs: CalcitList) => CalcitSliceList;
+export declare let _$n_str_$o_pad_left: (s: string, size: number, pattern: string) => string;
+export declare let _$n_str_$o_pad_right: (s: string, size: number, pattern: string) => string;
+export declare let _$n_get_os: () => CalcitTag;
+export declare let _$n_buffer: (...xs: CalcitValue[]) => Uint8Array;
+export declare let _$n_cirru_nth: (xs: CalcitCirruQuote, idx: number) => CalcitValue;
+export declare let _$n_cirru_type: (xs: CalcitCirruQuote, idx: number) => CalcitTag;
+export declare let _$n_hash: (x: CalcitValue) => number;
+export declare let _$n_cirru_quote_$o_to_list: (x: CalcitCirruQuote) => CalcitValue;
+export declare let reduce: (xs: CalcitValue, acc: CalcitValue, f: CalcitFn) => CalcitValue;
+export declare let _$n_reset_gensym_index_$x_: () => void;
+export declare let gensym: () => void;
+export declare let macroexpand: () => void;
+export declare let macroexpand_all: () => void;
+export declare let _$n_get_calcit_running_mode: () => void;
+export declare let _$n_get_def_doc: () => void;
+export declare let _$n_get_def_schema: () => void;
+export declare let raise: () => void;

package/lib/custom-formatter.d.mts

@@ -0,0 +1,8 @@
+declare global {
+    var devtoolsFormatters: {
+        header: (obj: any, config: any) => any[];
+        hasBody: (obj: any) => boolean;
+        body: (obj: any, config: any) => any[];
+    }[];
+}
+export declare let load_console_formatter_$x_: () => void;

package/lib/js-arity-helpers.d.mts

@@ -0,0 +1,3 @@
+export declare let _args_throw: (name: string, expected: number, got: number) => Error;
+export declare let _args_fewer_throw: (name: string, min: number, got: number) => Error;
+export declare let _args_between_throw: (name: string, min: number, max: number, got: number) => Error;

package/lib/js-buf-list.d.mts

@@ -0,0 +1,11 @@
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitSliceList } from "./js-list.mjs";
+export declare class CalcitBufList {
+    buf: CalcitValue[];
+    constructor(buf?: CalcitValue[]);
+}
+export declare function _$n_buf_list_$o_new(): CalcitBufList;
+export declare function _$n_buf_list_$o_push(buf: CalcitValue, item: CalcitValue): CalcitBufList;
+export declare function _$n_buf_list_$o_concat(buf: CalcitValue, xs: CalcitValue): CalcitBufList;
+export declare function _$n_buf_list_$o_to_list(buf: CalcitValue): CalcitSliceList;
+export declare function _$n_buf_list_$o_count(buf: CalcitValue): number;

package/lib/js-cirru.d.mts

@@ -0,0 +1,23 @@
+import { CirruWriterNode } from "@cirru/writer.ts";
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitList } from "./js-list.mjs";
+type CirruEdnFormat = string | CirruEdnFormat[];
+export declare class CalcitCirruQuote {
+    value: CirruWriterNode[];
+    constructor(value: CirruWriterNode[]);
+    toString(): string;
+    toList(): CalcitValue;
+    nth(idx: number): CalcitValue;
+    /** provide a simple text representation in Console or std out, with indentations */
+    textForm(): string;
+}
+export declare let format_cirru: (data: CalcitCirruQuote | CalcitList, useInline: boolean) => string;
+export declare let format_cirru_one_liner: (data: CalcitCirruQuote | CalcitList) => string;
+/** better use string version of Cirru EDN in future */
+export declare let to_cirru_edn: (x: CalcitValue) => CirruEdnFormat;
+export declare let extract_cirru_edn: (x: CirruEdnFormat, options: CalcitValue) => CalcitValue;
+export declare let format_cirru_edn: (data: CalcitValue, useInline?: boolean) => string;
+export declare let to_calcit_data: (x: any, noKeyword?: boolean) => CalcitValue;
+/** deep compare cirru array */
+export declare let cirru_deep_equal: (x: CirruWriterNode, y: CirruWriterNode) => boolean;
+export {};

package/lib/js-cirru.mjs

@@ -433,14 +433,12 @@ export let format_cirru_edn = (data, useInline = true) => {
         return "\ndo nil" + "\n";
     }
     if (typeof data === "string") {
-        return "\ndo " + to_cirru_edn(data) + "\n";
+        let quoted = writeCirruCode([[to_cirru_edn(data)]], { useInline: useInline }).trim();
+        return "\ndo " + quoted + "\n";
     }
     if (typeof data === "boolean") {
         return "\ndo " + to_cirru_edn(data) + "\n";
     }
-    if (typeof data === "string") {
-        return "\ndo " + to_cirru_edn(data) + "\n";
-    }
     if (data instanceof CalcitSymbol) {
         return "\ndo " + to_cirru_edn(data) + "\n";
     }

package/lib/js-enum.d.mts

@@ -0,0 +1,11 @@
+import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
+export declare class CalcitEnum {
+    prototype: CalcitRecord;
+    cachedHash: number;
+    constructor(prototype: CalcitRecord);
+    name(): string;
+    get impls(): CalcitImpl[];
+    withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitEnum;
+    toString(): string;
+}

package/lib/js-impl.d.mts

@@ -0,0 +1,15 @@
+import { Hash } from "@calcit/ternary-tree";
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitTag } from "./calcit-data.mjs";
+import type { CalcitTrait } from "./js-trait.mjs";
+export declare class CalcitImpl {
+    name: CalcitTag;
+    origin: CalcitTrait | null;
+    fields: Array<CalcitTag>;
+    values: Array<CalcitValue>;
+    cachedHash: Hash;
+    constructor(name: CalcitTag, fields: Array<CalcitTag>, values: Array<CalcitValue>, origin?: CalcitTrait | null);
+    get(k: CalcitValue): CalcitValue;
+    getOrNil(k: CalcitValue): CalcitValue;
+    toString(disableJsDataWarning?: boolean): string;
+}

package/lib/js-list.d.mts

@@ -0,0 +1,61 @@
+import { CalcitValue } from "./js-primes.mjs";
+import { TernaryTreeList, Hash } from "@calcit/ternary-tree";
+import { CalcitFn } from "./calcit-data.mjs";
+export declare class CalcitList {
+    value: TernaryTreeList<CalcitValue>;
+    cachedHash: Hash;
+    constructor(value: TernaryTreeList<CalcitValue>);
+    len(): number;
+    get(idx: number): CalcitValue;
+    assoc(idx: number, v: CalcitValue): CalcitList;
+    assocBefore(idx: number, v: CalcitValue): CalcitList;
+    assocAfter(idx: number, v: CalcitValue): CalcitList;
+    dissoc(idx: number): CalcitList;
+    slice(from: number, to: number): CalcitList;
+    toString(shorter?: boolean, disableJsDataWarning?: boolean): string;
+    isEmpty(): boolean;
+    /** usage: `for of` */
+    items(): Generator<CalcitValue>;
+    append(v: CalcitValue): CalcitList;
+    prepend(v: CalcitValue): CalcitList;
+    first(): CalcitValue;
+    rest(): CalcitList;
+    concat(ys: CalcitList | CalcitSliceList): CalcitList;
+    map(f: (v: CalcitValue) => CalcitValue): CalcitList;
+    toArray(): CalcitValue[];
+    reverse(): CalcitList;
+    nestedDataInChildren(): boolean;
+}
+export declare class CalcitSliceList {
+    value: Array<CalcitValue>;
+    start: number;
+    end: number;
+    cachedHash: Hash;
+    /** reference to converted list */
+    cachedTreeListRef: CalcitList;
+    constructor(value: Array<CalcitValue>);
+    turnListMode(): CalcitList;
+    len(): number;
+    get(idx: number): CalcitValue;
+    assoc(idx: number, v: CalcitValue): CalcitList;
+    assocBefore(idx: number, v: CalcitValue): CalcitList;
+    assocAfter(idx: number, v: CalcitValue): CalcitList | CalcitSliceList;
+    dissoc(idx: number): CalcitList | CalcitSliceList;
+    slice(from: number, to: number): CalcitSliceList;
+    toString(shorter?: boolean, disableJsDataWarning?: boolean): string;
+    isEmpty(): boolean;
+    /** usage: `for of` */
+    items(): Generator<CalcitValue>;
+    append(v: CalcitValue): CalcitSliceList | CalcitList;
+    prepend(v: CalcitValue): CalcitList;
+    first(): CalcitValue;
+    rest(): CalcitSliceList;
+    concat(ys: CalcitSliceList | CalcitList): CalcitList | CalcitSliceList;
+    map(f: (v: CalcitValue) => CalcitValue): CalcitSliceList;
+    toArray(): CalcitValue[];
+    reverse(): CalcitList;
+    nestedDataInChildren(): boolean;
+}
+export declare let foldl: (xs: CalcitValue, acc: CalcitValue, f: CalcitFn) => CalcitValue;
+export declare let foldl_shortcut: (xs: CalcitValue, acc: CalcitValue, v0: CalcitValue, f: CalcitFn) => CalcitValue;
+export declare let foldr_shortcut: (xs: CalcitValue, acc: CalcitValue, v0: CalcitValue, f: CalcitFn) => CalcitValue;

package/lib/js-map.d.mts

@@ -0,0 +1,60 @@
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitSet } from "./js-set.mjs";
+import { TernaryTreeMap, Hash } from "@calcit/ternary-tree";
+/** need to compare by Calcit */
+declare let DATA_EQUAL: (x: CalcitValue, y: CalcitValue) => boolean;
+export declare let overwriteMapComparator: (f: typeof DATA_EQUAL) => void;
+export declare class CalcitMap {
+    cachedHash: Hash;
+    value: TernaryTreeMap<CalcitValue, CalcitValue>;
+    constructor(value: TernaryTreeMap<CalcitValue, CalcitValue>);
+    len(): number;
+    get(k: CalcitValue): CalcitValue;
+    assoc(...args: CalcitValue[]): CalcitMap;
+    dissoc(...args: CalcitValue[]): CalcitMap;
+    toString(shorter?: boolean, disableJsDataWarning?: boolean): string;
+    isEmpty(): boolean;
+    pairs(): Array<[CalcitValue, CalcitValue]>;
+    keysArray(): Array<CalcitValue>;
+    contains(k: CalcitValue): boolean;
+    merge(ys: CalcitMap | CalcitSliceMap): CalcitMap;
+    mergeSkip(ys: CalcitMap | CalcitSliceMap, v: CalcitValue): CalcitMap;
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    diffNew(ys: CalcitMap | CalcitSliceMap): CalcitMap;
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    diffKeys(ys: CalcitMap | CalcitSliceMap): CalcitSet;
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    commonKeys(ys: CalcitMap | CalcitSliceMap): CalcitSet;
+    /** detecting in custom formatter */
+    nestedDataInChildren(): boolean;
+}
+export declare class CalcitSliceMap {
+    cachedHash: Hash;
+    /** in arrayMode, only flatten values, instead of tree structure */
+    chunk: CalcitValue[];
+    /** reference to generated HashMap in tree structure */
+    cachedTreeMapRef?: CalcitMap;
+    constructor(value: CalcitValue[]);
+    /** convert to tree map when needed, also cached in case converted over and over again  */
+    turnMap(): CalcitMap;
+    len(): number;
+    get(k: CalcitValue): CalcitValue;
+    assoc(...args: CalcitValue[]): CalcitMap | CalcitSliceMap;
+    dissoc(...args: CalcitValue[]): CalcitMap | CalcitSliceMap;
+    toString(shorter?: boolean, disableJsDataWarning?: boolean): string;
+    isEmpty(): boolean;
+    pairs(): Array<[CalcitValue, CalcitValue]>;
+    keysArray(): Array<CalcitValue>;
+    contains(k: CalcitValue): boolean;
+    merge(ys: CalcitMap | CalcitSliceMap): CalcitMap | CalcitSliceMap;
+    mergeSkip(ys: CalcitMap | CalcitSliceMap, v: CalcitValue): CalcitMap | CalcitSliceMap;
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    diffNew(ys: CalcitSliceMap | CalcitMap): CalcitMap;
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    diffKeys(ys: CalcitMap | CalcitSliceMap): CalcitSet;
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    commonKeys(ys: CalcitMap | CalcitSliceMap): CalcitSet;
+    /** detecting in custom formatter */
+    nestedDataInChildren(): boolean;
+}
+export {};

package/lib/js-primes.d.mts

@@ -0,0 +1,15 @@
+import { CalcitTag, CalcitSymbol, CalcitFn, CalcitRecur } from "./calcit-data.mjs";
+import { CalcitRef } from "./js-ref.mjs";
+import { CalcitList, CalcitSliceList } from "./js-list.mjs";
+import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
+import { CalcitStruct } from "./js-struct.mjs";
+import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
+import { CalcitSet as CalcitSet } from "./js-set.mjs";
+import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitCirruQuote } from "./js-cirru.mjs";
+import { CalcitTrait } from "./js-trait.mjs";
+export type CalcitValue = string | number | boolean | CalcitMap | CalcitSliceMap | CalcitList | CalcitSliceList | CalcitSet | CalcitTag | CalcitSymbol | CalcitRef | CalcitTuple | CalcitFn | CalcitRecur | CalcitRecord | CalcitImpl | CalcitTrait | CalcitStruct | CalcitEnum | CalcitCirruQuote | null;
+export declare let isLiteral: (x: CalcitValue) => boolean;
+export declare let _$n_compare: (a: CalcitValue, b: CalcitValue) => number;

package/lib/js-record.d.mts

@@ -0,0 +1,36 @@
+import { Hash } from "@calcit/ternary-tree";
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
+import { CalcitTag } from "./calcit-data.mjs";
+import { CalcitStruct } from "./js-struct.mjs";
+export declare class CalcitRecord {
+    name: CalcitTag;
+    fields: Array<CalcitTag>;
+    values: Array<CalcitValue>;
+    structRef: CalcitStruct;
+    cachedHash: Hash;
+    constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStruct);
+    get(k: CalcitValue): CalcitValue;
+    getOrNil(k: CalcitValue): CalcitValue;
+    assoc(k: CalcitValue, v: CalcitValue): CalcitRecord;
+    /** return -1 for missing */
+    findIndex(k: CalcitValue): number;
+    contains(k: CalcitValue): boolean;
+    toString(disableJsDataWarning?: boolean): string;
+    withImpls(impl: CalcitValue | CalcitImpl[]): CalcitRecord;
+}
+export declare let new_record: (name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
+export declare let new_impl_record: (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
+/** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
+ *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+export declare let _$q__$M_: (...xs: Array<CalcitValue>) => CalcitValue;
+export declare let fieldsEqual: (xs: Array<CalcitTag>, ys: Array<CalcitTag>) => boolean;
+export declare let _$n__PCT__$M_: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
+export declare let _$n__PCT__$M__$q_: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
+export declare let _$n_record_$o_with: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
+export declare let _$n_record_$o_get_name: (x: CalcitValue) => CalcitTag;
+export declare let _$n_record_$o_struct: (x: CalcitValue) => CalcitValue;
+export declare let _$n_record_$o_from_map: (proto: CalcitValue, data: CalcitValue) => CalcitValue;
+export declare let _$n_record_$o_to_map: (x: CalcitValue) => CalcitValue;
+export declare let _$n_record_$o_matches_$q_: (x: CalcitValue, y: CalcitValue) => boolean;
+export declare function _$n_record_$o_extend_as(obj: CalcitValue, new_name: CalcitValue, new_key: CalcitValue, new_value: CalcitValue): CalcitRecord;

package/lib/js-ref.d.mts

@@ -0,0 +1,12 @@
+import { Hash } from "@calcit/ternary-tree";
+import type { CalcitFn } from "./calcit-data.mjs";
+import type { CalcitValue } from "./js-primes.mts";
+export declare class CalcitRef {
+    value: CalcitValue;
+    path: string;
+    listeners: Map<CalcitValue, CalcitFn>;
+    cachedHash: Hash;
+    constructor(x: CalcitValue, path: string);
+    toString(): string;
+}
+export declare let atom: (x: CalcitValue) => CalcitValue;

package/lib/js-set.d.mts

@@ -0,0 +1,23 @@
+import { CalcitValue } from "./js-primes.mjs";
+import { TernaryTreeMap, Hash } from "@calcit/ternary-tree";
+import { CalcitSliceList } from "./js-list.mjs";
+/** need to compare by Calcit */
+declare let DATA_EQUAL: (x: CalcitValue, y: CalcitValue) => boolean;
+export declare let overwriteSetComparator: (f: typeof DATA_EQUAL) => void;
+export declare class CalcitSet {
+    value: TernaryTreeMap<CalcitValue, boolean>;
+    cachedHash: Hash;
+    constructor(value: TernaryTreeMap<CalcitValue, boolean> | Array<CalcitValue>);
+    len(): number;
+    contains(y: CalcitValue): boolean;
+    include(y: CalcitValue): CalcitSet;
+    exclude(y: CalcitValue): CalcitSet;
+    difference(ys: CalcitSet): CalcitSet;
+    union(ys: CalcitSet): CalcitSet;
+    intersection(ys: CalcitSet): CalcitSet;
+    destruct(): CalcitSliceList;
+    toString(disableJsDataWarning?: boolean): string;
+    values(): CalcitValue[];
+    nestedDataInChildren(): boolean;
+}
+export {};

package/lib/js-struct.d.mts

@@ -0,0 +1,13 @@
+import { CalcitTag } from "./calcit-data.mjs";
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
+export declare class CalcitStruct {
+    name: CalcitTag;
+    fields: CalcitTag[];
+    fieldTypes: CalcitValue[];
+    impls: CalcitImpl[];
+    cachedHash: number;
+    constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls?: CalcitImpl[]);
+    withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStruct;
+    toString(disableJsDataWarning?: boolean): string;
+}

package/lib/js-tag-helpers.d.mts

@@ -0,0 +1,2 @@
+import { CalcitTag } from "./calcit-data.mjs";
+export declare let init_tags: (arr: string[]) => Record<string, CalcitTag>;

package/lib/js-trait.d.mts

@@ -0,0 +1,9 @@
+import { CalcitTag } from "./calcit-data.mjs";
+import { CalcitValue } from "./js-primes.mjs";
+export declare class CalcitTrait {
+    name: CalcitTag;
+    methods: CalcitTag[];
+    methodTypes: CalcitValue[];
+    constructor(name: CalcitValue, methods: CalcitValue[], methodTypes: CalcitValue[]);
+    toString(disableJsDataWarning?: boolean): string;
+}