res-pareto-build 0.9.0 → 0.11.0

package/dist/api.generated.d.ts

@@ -1,26 +1,22 @@
 import * as g_common from "glo-pareto-common";
 import * as g_this from "./glossary";
+export declare namespace D {
+}
 export declare namespace A {
-    type buildArray = g_this.SYNC.A.F.BuildArray;
-    type createAsyncArrayBuilder = g_this.ASYNC.A.C.CreateArrayBuilder;
-    type createAsyncIgnoringDictionaryBuilder = g_this.ASYNC.A.C.CreateSafeDictionaryBuilder;
-    type createAsyncOverwritingDictionaryBuilder = g_this.ASYNC.A.C.CreateSafeDictionaryBuilder;
-    type createSyncIgnoringDictionaryBuilder = ($d: {}, $se: {
-        readonly 'onDuplicate': g_common.SYNC.I.String;
-    }) => g_this.SYNC.A.F.BuildDictionary;
-    type createSyncOverwritingDictionaryBuilder = ($d: {}, $se: {
+    type buildArray = () => g_this.SYNC.A.F.BuildArray;
+    type buildSafeDictionary = ($: g_this.T.DictionaryBuildStrategy, $se: {
         readonly 'onDuplicate': g_common.SYNC.I.String;
-    }) => g_this.SYNC.A.F.BuildDictionary;
-    type createUnsafeAsyncDictionaryBuilder = g_this.ASYNC.A.C.CreateUnsafeDictionaryBuilder;
-    type unsafeSyncBuildDictionary = g_this.SYNC.A.F.BuildDictionary;
+    }) => g_this.SYNC.A.F.BuildSafeDictionary;
+    type buildUnsafeDictionary = () => g_this.SYNC.A.F.BuildUnsafeDictionary;
+    type createArrayBuilder = () => g_this.ASYNC.A.C.CreateArrayBuilder;
+    type createSafeDictionaryBuilder = ($: g_this.T.DictionaryBuildStrategy) => g_this.ASYNC.A.C.CreateSafeDictionaryBuilder;
+    type createUnsafeDictionaryBuilder = () => g_this.ASYNC.A.C.CreateUnsafeDictionaryBuilder;
 }
 export type API = {
-    buildArray: A.buildArray;
-    createAsyncArrayBuilder: A.createAsyncArrayBuilder;
-    createAsyncIgnoringDictionaryBuilder: A.createAsyncIgnoringDictionaryBuilder;
-    createAsyncOverwritingDictionaryBuilder: A.createAsyncOverwritingDictionaryBuilder;
-    createSyncIgnoringDictionaryBuilder: A.createSyncIgnoringDictionaryBuilder;
-    createSyncOverwritingDictionaryBuilder: A.createSyncOverwritingDictionaryBuilder;
-    createUnsafeAsyncDictionaryBuilder: A.createUnsafeAsyncDictionaryBuilder;
-    unsafeSyncBuildDictionary: A.unsafeSyncBuildDictionary;
+    readonly 'buildArray': A.buildArray;
+    readonly 'buildSafeDictionary': A.buildSafeDictionary;
+    readonly 'buildUnsafeDictionary': A.buildUnsafeDictionary;
+    readonly 'createArrayBuilder': A.createArrayBuilder;
+    readonly 'createSafeDictionaryBuilder': A.createSafeDictionaryBuilder;
+    readonly 'createUnsafeDictionaryBuilder': A.createUnsafeDictionaryBuilder;
 };

package/dist/glossary/algorithmtypes.generated.d.ts

@@ -2,55 +2,60 @@ import { T } from "./datatypes.generated";
 import * as g_common from "glo-pareto-common";
 export declare namespace ASYNC {
     namespace I {
-        type Array<GType> = ($: T.Array<GType>) => void;
-        type Dictionary<GType> = ($: T.Dictionary<GType>) => void;
-        type DuplicatesHandler<GType> = {
+        type Array<TEndType, TType> = ($: T.Array<TEndType, TType>) => void;
+        type Dictionary<TEndType, TType> = ($: T.Dictionary<TEndType, TType>) => void;
+        type DuplicatesHandler = {
             'data': ($: g_common.T.String) => void;
             'end': () => void;
         };
-        type Elements<GType> = {
-            'data': ($: T.Type<GType>) => void;
-            'end': () => void;
+        type Elements<TEndType, TType> = {
+            'data': ($: TType) => void;
+            'end': ($: TEndType) => void;
         };
-        type Entries<GType> = {
-            'data': ($: T.KeyValuePair<GType>) => void;
-            'end': () => void;
+        type Entries<TEndType, TType> = {
+            'data': ($: T.KeyValuePair<TType>) => void;
+            'end': ($: TEndType) => void;
         };
     }
     namespace A {
         namespace C {
-            type CreateArrayBuilder = <GType>($is: {
-                'handler': ASYNC.I.Array<GType>;
-            }) => ASYNC.I.Elements<GType>;
+            type CreateArrayBuilder = {
+                'construct': <TEndType, TType>($is: {
+                    readonly 'handler': ASYNC.I.Array<TEndType, TType>;
+                }) => ASYNC.I.Elements<TEndType, TType>;
+            };
         }
         namespace C {
-            type CreateSafeDictionaryBuilder = <GType>($is: {
-                'duplicatesHandler': ASYNC.I.DuplicatesHandler<GType>;
-                'handler': ASYNC.I.Dictionary<GType>;
-            }) => ASYNC.I.Entries<GType>;
+            type CreateSafeDictionaryBuilder = {
+                'construct': <TEndType, TType>($is: {
+                    readonly 'duplicatesHandler': ASYNC.I.DuplicatesHandler;
+                    readonly 'handler': ASYNC.I.Dictionary<TEndType, TType>;
+                }) => ASYNC.I.Entries<TEndType, TType>;
+            };
         }
         namespace C {
-            type CreateUnsafeDictionaryBuilder = <GType>($is: {
-                'handler': ASYNC.I.Dictionary<GType>;
-            }) => ASYNC.I.Entries<GType>;
+            type CreateUnsafeDictionaryBuilder = {
+                'construct': <TEndType, TType>($is: {
+                    readonly 'handler': ASYNC.I.Dictionary<TEndType, TType>;
+                }) => ASYNC.I.Entries<TEndType, TType>;
+            };
         }
     }
 }
 export declare namespace SYNC {
     namespace I {
-        type Add<GType> = ($: T.KeyValuePair<GType>) => void;
-        type Push<GType> = ($: T.Type<GType>) => void;
-    }
-    namespace IW {
-        type Add<GType> = ($c: ($b: I.Add<GType>) => void) => void;
-        type Push<GType> = ($c: ($b: I.Push<GType>) => void) => void;
+        type Add<TType> = ($: T.KeyValuePair<TType>) => void;
+        type Push<TType> = ($: TType) => void;
     }
     namespace A {
         namespace F {
-            type BuildArray = <GType>($c: ($b: SYNC.I.Push<GType>) => void) => T.Array<GType>;
+            type BuildArray = <TType>($c: ($i: SYNC.I.Push<TType>) => void) => g_common.T.Array<TType>;
+        }
+        namespace F {
+            type BuildSafeDictionary = <TType>($c: ($i: SYNC.I.Add<TType>) => void) => g_common.T.Dictionary<TType>;
         }
         namespace F {
-            type BuildDictionary = <GType>($c: ($b: SYNC.I.Add<GType>) => void) => T.Dictionary<GType>;
+            type BuildUnsafeDictionary = <TType>($c: ($i: SYNC.I.Add<TType>) => void) => g_common.T.Dictionary<TType>;
         }
     }
 }

package/dist/glossary/datatypes.generated.d.ts

@@ -1,27 +1,35 @@
-import * as pt from 'pareto-core-types';
+import * as g_common from "glo-pareto-common";
+export declare namespace N { }
 export declare namespace T {
     namespace Array {
-        type A<GType> = GType;
+        type array<TEndType, TType> = g_common.T.Array<TType>;
+        type end<TEndType, TType> = TEndType;
     }
-    type Array<GType> = pt.Array<GType>;
+    type Array<TEndType, TType> = {
+        readonly 'array': g_common.T.Array<TType>;
+        readonly 'end': TEndType;
+    };
     namespace Dictionary {
-        type D<GType> = GType;
+        type dictionary<TEndType, TType> = g_common.T.Dictionary<TType>;
+        type end<TEndType, TType> = TEndType;
     }
-    type Dictionary<GType> = pt.Dictionary<GType>;
+    type Dictionary<TEndType, TType> = {
+        readonly 'dictionary': g_common.T.Dictionary<TType>;
+        readonly 'end': TEndType;
+    };
     namespace DictionaryBuildStrategy {
         namespace ignore { }
-        type ignore<GType> = null;
+        type ignore = null;
         namespace overwrite { }
-        type overwrite<GType> = null;
+        type overwrite = null;
     }
-    type DictionaryBuildStrategy<GType> = ['ignore', null] | ['overwrite', null];
+    type DictionaryBuildStrategy = ['ignore', null] | ['overwrite', null];
     namespace KeyValuePair {
-        type key<GType> = string;
-        type value<GType> = GType;
+        type key<TType> = string;
+        type value<TType> = TType;
     }
-    type KeyValuePair<GType> = {
+    type KeyValuePair<TType> = {
         readonly 'key': string;
-        readonly 'value': GType;
+        readonly 'value': TType;
     };
-    type Type<GType> = GType;
 }

package/dist/implementation.generated.js

@@ -2,20 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$r = void 0;
 const buildArray_native_1 = require("./implementations/buildArray.native");
-const createAsyncArrayBuilder_native_1 = require("./implementations/createAsyncArrayBuilder.native");
-const createAsyncIgnoringDictionaryBuilder_native_1 = require("./implementations/createAsyncIgnoringDictionaryBuilder.native");
-const createAsyncOverwritingDictionaryBuilder_native_1 = require("./implementations/createAsyncOverwritingDictionaryBuilder.native");
-const createSyncIgnoringDictionaryBuilder_native_1 = require("./implementations/createSyncIgnoringDictionaryBuilder.native");
-const createSyncOverwritingDictionaryBuilder_native_1 = require("./implementations/createSyncOverwritingDictionaryBuilder.native");
-const createUnsafeAsyncDictionaryBuilder_native_1 = require("./implementations/createUnsafeAsyncDictionaryBuilder.native");
-const unsafeSyncBuildDictionary_native_1 = require("./implementations/unsafeSyncBuildDictionary.native");
+const buildSafeDictionary_native_1 = require("./implementations/buildSafeDictionary.native");
+const buildUnsafeDictionary_native_1 = require("./implementations/buildUnsafeDictionary.native");
+const createArrayBuilder_native_1 = require("./implementations/createArrayBuilder.native");
+const createSafeDictionaryBuilder_native_1 = require("./implementations/createSafeDictionaryBuilder.native");
+const createUnsafeDictionaryBuilder_native_1 = require("./implementations/createUnsafeDictionaryBuilder.native");
 exports.$r = {
     'buildArray': buildArray_native_1.$$,
-    'createAsyncArrayBuilder': createAsyncArrayBuilder_native_1.$$,
-    'createAsyncIgnoringDictionaryBuilder': createAsyncIgnoringDictionaryBuilder_native_1.$$,
-    'createAsyncOverwritingDictionaryBuilder': createAsyncOverwritingDictionaryBuilder_native_1.$$,
-    'createSyncIgnoringDictionaryBuilder': createSyncIgnoringDictionaryBuilder_native_1.$$,
-    'createSyncOverwritingDictionaryBuilder': createSyncOverwritingDictionaryBuilder_native_1.$$,
-    'createUnsafeAsyncDictionaryBuilder': createUnsafeAsyncDictionaryBuilder_native_1.$$,
-    'unsafeSyncBuildDictionary': unsafeSyncBuildDictionary_native_1.$$,
+    'buildSafeDictionary': buildSafeDictionary_native_1.$$,
+    'buildUnsafeDictionary': buildUnsafeDictionary_native_1.$$,
+    'createArrayBuilder': createArrayBuilder_native_1.$$,
+    'createSafeDictionaryBuilder': createSafeDictionaryBuilder_native_1.$$,
+    'createUnsafeDictionaryBuilder': createUnsafeDictionaryBuilder_native_1.$$,
 };

package/dist/implementations/buildArray.native.js

@@ -25,11 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($c) => {
-    const out = [];
-    $c(($) => {
-        out.push($);
-    });
-    return pi.wrapRawArray(out);
+const $$ = () => {
+    return ($c) => {
+        const out = [];
+        $c(($) => {
+            out.push($);
+        });
+        return pi.wrapRawArray(out);
+    };
 };
 exports.$$ = $$;

package/dist/implementations/buildSafeDictionary.native.d.ts

@@ -0,0 +1,2 @@
+import { A } from "../api.generated";
+export declare const $$: A.buildSafeDictionary;

package/dist/implementations/{createSyncOverwritingDictionaryBuilder.native.js → buildSafeDictionary.native.js}

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($d, $se) => {
+const $$ = ($x, $se) => {
     return ($c) => {
         const out = {};
         $c(($) => {
@@ -33,7 +33,19 @@ const $$ = ($d, $se) => {
                 out[$.key] = $.value;
             }
             else {
-                out[$.key] = $.value;
+                const x = $;
+                switch ($x[0]) {
+                    case 'ignore':
+                        pi.cc($x[1], ($) => {
+                        });
+                        break;
+                    case 'overwrite':
+                        pi.cc($x[1], ($) => {
+                            out[x.key] = x.value;
+                        });
+                        break;
+                    default: pi.au($x[0]);
+                }
                 $se.onDuplicate($.key);
             }
         });

package/dist/implementations/buildUnsafeDictionary.native.d.ts

@@ -0,0 +1,2 @@
+import { A } from "../api.generated";
+export declare const $$: A.buildUnsafeDictionary;

package/dist/implementations/{createSyncIgnoringDictionaryBuilder.native.js → buildUnsafeDictionary.native.js}

@@ -25,16 +25,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($d, $se) => {
+const $$ = () => {
     return ($c) => {
         const out = {};
         $c(($) => {
-            if (out[$.key] === undefined) {
-                out[$.key] = $.value;
-            }
-            else {
-                $se.onDuplicate($.key);
+            if (out[$.key] !== undefined) {
+                pi.panic(`entry '${$.key}' already exists`);
             }
+            out[$.key] = $.value;
         });
         return pi.wrapRawDictionary(out);
     };

package/dist/implementations/createArrayBuilder.native.d.ts

@@ -0,0 +1,2 @@
+import { A } from "../api.generated";
+export declare const $$: A.createArrayBuilder;

package/dist/implementations/{createAsyncOverwritingDictionaryBuilder.native.js → createArrayBuilder.native.js}

@@ -25,18 +25,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const dict = {};
+const $$ = () => {
     return {
-        'data': ($) => {
-            if (dict[$.key] !== undefined) {
-                $is.duplicatesHandler.data($.key);
-            }
-            dict[$.key] = $.value;
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawDictionary(dict));
-            $is.duplicatesHandler.end();
+        'construct': ($is) => {
+            const arr = [];
+            return {
+                'data': ($) => {
+                    arr.push($);
+                },
+                'end': ($) => {
+                    $is.handler({
+                        'end': $,
+                        'array': pi.wrapRawArray(arr)
+                    });
+                }
+            };
         }
     };
 };

package/dist/implementations/createSafeDictionaryBuilder.native.d.ts

@@ -0,0 +1,2 @@
+import { A } from "../api.generated";
+export declare const $$: A.createSafeDictionaryBuilder;

package/dist/implementations/{unsafeSyncBuildDictionary.native.js → createSafeDictionaryBuilder.native.js}

@@ -26,13 +26,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
 const $$ = ($c) => {
-    const out = {};
-    $c(($) => {
-        if (out[$.key] !== undefined) {
-            pi.panic(`entry '${$.key}' already exists`);
+    return {
+        'construct': ($is) => {
+            const dict = {};
+            return {
+                'data': ($) => {
+                    if (dict[$.key] !== undefined) {
+                        const x = $;
+                        switch ($c[0]) {
+                            case 'ignore':
+                                pi.cc($c[1], ($) => {
+                                });
+                                break;
+                            case 'overwrite':
+                                pi.cc($c[1], ($) => {
+                                    dict[x.key] = x.value;
+                                });
+                                break;
+                            default: pi.au($c[0]);
+                        }
+                        $is.duplicatesHandler.data($.key);
+                    }
+                    else {
+                        dict[$.key] = $.value;
+                    }
+                },
+                'end': ($) => {
+                    $is.handler({
+                        'dictionary': pi.wrapRawDictionary(dict),
+                        'end': $,
+                    });
+                    $is.duplicatesHandler.end();
+                }
+            };
         }
-        out[$.key] = $.value;
-    });
-    return pi.wrapRawDictionary(out);
+    };
 };
 exports.$$ = $$;

package/dist/implementations/createUnsafeDictionaryBuilder.native.d.ts

@@ -0,0 +1,2 @@
+import { A } from "../api.generated";
+export declare const $$: A.createUnsafeDictionaryBuilder;

package/dist/implementations/{createAsyncArrayBuilder.native.js → createUnsafeDictionaryBuilder.native.js}

@@ -25,14 +25,24 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$$ = void 0;
 const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const arr = [];
+const $$ = () => {
     return {
-        'data': ($) => {
-            arr.push($);
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawArray(arr));
+        'construct': ($is) => {
+            const dict = {};
+            return {
+                'data': ($) => {
+                    if (dict[$.key] !== undefined) {
+                        pi.panic(`duplicate key: ${$.key}`);
+                    }
+                    dict[$.key] = $.value;
+                },
+                'end': ($) => {
+                    $is.handler({
+                        'dictionary': pi.wrapRawDictionary(dict),
+                        'end': $
+                    });
+                }
+            };
         }
     };
 };

package/package.json

@@ -3,8 +3,8 @@
   "license": "TBD",
   "description": "this library provides functions to build arrays and dictionaries by adding entries/elements one by one",
   "dependencies": {
-    "glo-pareto-common": "^0.23.0",
-    "pareto-core-internals": "^0.13.2"
+    "glo-pareto-common": "^0.28.0",
+    "pareto-core-internals": "^0.13.4"
   },
   "files": [
     "dist"
@@ -16,6 +16,6 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "name": "res-pareto-build",
-  "version": "0.9.0",
-  "content-fingerprint": "cbd5ea1268bca538a30032e1e752e895c73223f4"
+  "version": "0.11.0",
+  "content-fingerprint": "12ff37e1a36c0f336eedf4891c3d4e189f76cca7"
 }

package/dist/implementations/createAsyncArrayBuilder.native.d.ts

@@ -1,2 +0,0 @@
-import { A } from "../api.generated";
-export declare const $$: A.createAsyncArrayBuilder;

package/dist/implementations/createAsyncIgnoringDictionaryBuilder.native.d.ts

@@ -1,2 +0,0 @@
-import { A } from "../api.generated";
-export declare const $$: A.createAsyncIgnoringDictionaryBuilder;

package/dist/implementations/createAsyncIgnoringDictionaryBuilder.native.js

@@ -1,45 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$$ = void 0;
-const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const dict = {};
-    return {
-        'data': ($) => {
-            if (dict[$.key] !== undefined) {
-                $is.duplicatesHandler.data($.key);
-            }
-            else {
-                dict[$.key] = $.value;
-            }
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawDictionary(dict));
-            $is.duplicatesHandler.end();
-        }
-    };
-};
-exports.$$ = $$;

package/dist/implementations/createAsyncOverwritingDictionaryBuilder.native.d.ts

@@ -1,2 +0,0 @@
-import { A } from "../api.generated";
-export declare const $$: A.createAsyncOverwritingDictionaryBuilder;

package/dist/implementations/createSyncIgnoringDictionaryBuilder.native.d.ts

@@ -1,2 +0,0 @@
-import { A } from "../api.generated";
-export declare const $$: A.createSyncIgnoringDictionaryBuilder;

package/dist/implementations/createSyncOverwritingDictionaryBuilder.native.d.ts

@@ -1,2 +0,0 @@
-import { A } from "../api.generated";
-export declare const $$: A.createSyncOverwritingDictionaryBuilder;

package/dist/implementations/createUnsafeAsyncDictionaryBuilder.native.d.ts

@@ -1,2 +0,0 @@
-import { A } from "../api.generated";
-export declare const $$: A.createUnsafeAsyncDictionaryBuilder;

package/dist/implementations/createUnsafeAsyncDictionaryBuilder.native.js

@@ -1,42 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$$ = void 0;
-const pi = __importStar(require("pareto-core-internals"));
-const $$ = ($is) => {
-    const dict = {};
-    return {
-        'data': ($) => {
-            if (dict[$.key] !== undefined) {
-                pi.panic(`duplicate key: ${$.key}`);
-            }
-            dict[$.key] = $.value;
-        },
-        'end': () => {
-            $is.handler(pi.wrapRawDictionary(dict));
-        }
-    };
-};
-exports.$$ = $$;

package/dist/implementations/unsafeSyncBuildDictionary.native.d.ts

@@ -1,2 +0,0 @@
-import { A } from "../api.generated";
-export declare const $$: A.unsafeSyncBuildDictionary;