@es-joy/jsoe 0.3.0 → 0.4.0

package/dist/vendor/typeson-registry/dist/index.d.ts

@@ -0,0 +1,400 @@
+declare var l: string[];
+declare var u: Typeson;
+declare class e {
+    private constructor();
+    then(t: any, r: any): any;
+    catch(e: any): any;
+}
+declare var p: any;
+export const arrayNonindexKeys: ({
+    arrayNonindexKeys: {
+        testPlainObjects: boolean;
+        test(x: any, stateObj: any): boolean;
+        replace(a: any, stateObj: any): any;
+        revive(o: any): any[];
+    };
+    sparseUndefined?: undefined;
+} | {
+    sparseUndefined: {
+        test(x: any, stateObj: any): boolean;
+        replace(n: any): number;
+        revive(s: any): undefined;
+    };
+    arrayNonindexKeys?: undefined;
+})[];
+export namespace arraybuffer {
+    namespace arraybuffer {
+        function test(x: any): boolean;
+        function replace(b: any, stateObj: any): string | {
+            index: any;
+        };
+        function revive(b64: any, stateObj: any): any;
+    }
+}
+export namespace bigint {
+    namespace bigint {
+        function test(x: any): boolean;
+        const replace: StringConstructor;
+        const revive: BigIntConstructor;
+    }
+}
+export namespace bigintObject {
+    namespace bigintObject {
+        export function test(x: any): boolean;
+        const replace_1: StringConstructor;
+        export { replace_1 as replace };
+        export function revive(s: any): Object;
+    }
+}
+export namespace blob {
+    namespace blob {
+        function test(x: any): boolean;
+        function replace(b: any): {
+            type: any;
+            stringContents: string;
+        };
+        function revive({ type, stringContents }: {
+            type: any;
+            stringContents: any;
+        }): Blob;
+        function replaceAsync(b: any): any;
+    }
+}
+declare const expObj$1: {}[];
+export namespace cloneable {
+    namespace cloneable {
+        function test(x: any): any;
+        function replace(clonable: any): {
+            uuid: string;
+            encapsulated: any;
+        };
+        function revive({ uuid, encapsulated }: {
+            uuid: any;
+            encapsulated: any;
+        }): any;
+    }
+}
+export namespace cryptokey {
+    namespace cryptokey {
+        function test(x: any): any;
+        function replaceAsync(key: any): any;
+        function revive({ jwk, algorithm, usages }: {
+            jwk: any;
+            algorithm: any;
+            usages: any;
+        }): Promise<CryptoKey>;
+    }
+}
+export namespace dataview {
+    namespace dataview {
+        function test(x: any): boolean;
+        function replace({ buffer, byteOffset, byteLength }: {
+            buffer: any;
+            byteOffset: any;
+            byteLength: any;
+        }, stateObj: any): {
+            index: any;
+            byteOffset: any;
+            byteLength: any;
+            encoded?: undefined;
+        } | {
+            encoded: string;
+            byteOffset: any;
+            byteLength: any;
+            index?: undefined;
+        };
+        function revive(b64Obj: any, stateObj: any): DataView;
+    }
+}
+export namespace date {
+    namespace date {
+        function test(x: any): boolean;
+        function replace(dt: any): any;
+        function revive(time: any): Date;
+    }
+}
+export namespace error {
+    namespace error {
+        function test(x: any): boolean;
+        function replace({ name, message, cause, stack, fileName, lineNumber, columnNumber }: {
+            name: any;
+            message: any;
+            cause: any;
+            stack: any;
+            fileName: any;
+            lineNumber: any;
+            columnNumber: any;
+        }): {
+            name: any;
+            message: any;
+            cause: any;
+            stack: any;
+            fileName: any;
+            lineNumber: any;
+            columnNumber: any;
+        };
+        function revive(obj: any): Error;
+    }
+}
+export const errors: {};
+export function escapeKeyPathComponent(e: any): any;
+export namespace file {
+    namespace file {
+        function test(x: any): boolean;
+        function replace(f: any): {
+            type: any;
+            stringContents: string;
+            name: any;
+            lastModified: any;
+        };
+        function revive({ name, type, stringContents, lastModified }: {
+            name: any;
+            type: any;
+            stringContents: any;
+            lastModified: any;
+        }): File;
+        function replaceAsync(f: any): any;
+    }
+}
+export namespace filelist {
+    import file_1 = file.file;
+    export { file_1 as file };
+    export namespace filelist {
+        function test(x: any): boolean;
+        function replace(fl: any): any[];
+        function revive(o: any): {
+            _files: any;
+            length: any;
+            /**
+             * @param {Integer} index
+             * @returns {File}
+             */
+            item(index: Integer): File;
+            /**
+             * @returns {"FileList"}
+             */
+            readonly [Symbol.toStringTag]: "FileList";
+        };
+    }
+}
+export function getByKeyPath(e: any, t: any): any;
+export function getJSONType(e: any): any;
+export function hasConstructorOf(e: any, t: any): boolean;
+export namespace imagebitmap {
+    namespace imagebitmap {
+        function test(x: any): any;
+        function replace(bm: any): string;
+        function revive(o: any): HTMLCanvasElement;
+        function reviveAsync(o: any): Promise<ImageBitmap>;
+    }
+}
+export namespace imagedata {
+    namespace imagedata {
+        function test(x: any): boolean;
+        function replace(d: any): {
+            array: any[];
+            width: any;
+            height: any;
+        };
+        function revive(o: any): ImageData;
+    }
+}
+export namespace infinity {
+    namespace infinity {
+        function test(x: any): boolean;
+        function replace(n: any): string;
+        function revive(s: any): number;
+    }
+}
+export namespace intlTypes {
+    export { IntlCollator };
+    export { IntlDateTimeFormat };
+    export { IntlNumberFormat };
+}
+export function isObject(e: any): any;
+export function isPlainObject(e: any): boolean;
+export function isThenable(e: any, t: any): any;
+export function isUserObject(e: any): any;
+export namespace map {
+    namespace map {
+        function test(x: any): boolean;
+        function replace(mp: any): any[];
+        function revive(entries: any): Map<any, any>;
+    }
+}
+export namespace nan {
+    namespace nan {
+        function test(x: any): boolean;
+        function replace(n: any): string;
+        function revive(s: any): number;
+    }
+}
+export namespace negativeInfinity {
+    namespace negativeInfinity {
+        function test(x: any): boolean;
+        function replace(n: any): string;
+        function revive(s: any): number;
+    }
+}
+export namespace negativeZero {
+    namespace negativeZero {
+        function test(x: any): boolean;
+        function replace(n: any): number;
+        function revive(s: any): number;
+    }
+}
+export namespace nonbuiltinIgnore {
+    namespace nonbuiltinIgnore {
+        function test(x: any): any;
+        function replace(rexp: any): void;
+    }
+}
+export const postmessage: {}[];
+export namespace primitiveObjects {
+    namespace StringObject {
+        export function test(x: any): boolean;
+        const replace_2: StringConstructor;
+        export { replace_2 as replace };
+        export function revive(s: any): String;
+    }
+    namespace BooleanObject {
+        export function test(x: any): boolean;
+        const replace_3: BooleanConstructor;
+        export { replace_3 as replace };
+        export function revive(b: any): Boolean;
+    }
+    namespace NumberObject {
+        export function test(x: any): boolean;
+        const replace_4: NumberConstructor;
+        export { replace_4 as replace };
+        export function revive(n: any): Number;
+    }
+}
+export namespace regexp {
+    namespace regexp {
+        function test(x: any): boolean;
+        function replace(rexp: any): {
+            source: any;
+            flags: string;
+        };
+        function revive({ source, flags }: {
+            source: any;
+            flags: any;
+        }): RegExp;
+    }
+}
+export namespace resurrectable {
+    namespace resurrectable {
+        function test(x: any): any;
+        function replace(rsrrctble: any): string;
+        function revive(serializedResurrectable: any): any;
+    }
+}
+export namespace set {
+    namespace set {
+        function test(x: any): boolean;
+        function replace(st: any): any[];
+        function revive(values: any): Set<any>;
+    }
+}
+export function setAtKeyPath(e: any, t: any, r: any): any;
+export const socketio: {}[];
+export const sparseUndefined: ({
+    sparseArrays: {
+        testPlainObjects: boolean;
+        test(x: any): boolean;
+        replace(a: any, stateObj: any): any;
+    };
+    sparseUndefined?: undefined;
+} | {
+    sparseUndefined: {
+        test(x: any, stateObj: any): boolean;
+        replace(n: any): number;
+        revive(s: any): undefined;
+    };
+    sparseArrays?: undefined;
+})[];
+export const specialNumbers: ({
+    infinity: {
+        test(x: any): boolean;
+        replace(n: any): string;
+        revive(s: any): number;
+    };
+} | {
+    nan: {
+        test(x: any): boolean;
+        replace(n: any): string;
+        revive(s: any): number;
+    };
+} | {
+    negativeInfinity: {
+        test(x: any): boolean;
+        replace(n: any): string;
+        revive(s: any): number;
+    };
+} | {
+    negativeZero: {
+        test(x: any): boolean;
+        replace(n: any): number;
+        revive(s: any): number;
+    };
+})[];
+declare const expObj: {}[];
+export var structuredCloningThrowing: {}[];
+export function toStringTag(e: any): string;
+export const typedArrays: {};
+declare const typedArraysSocketIO: {};
+declare namespace undef$1 {
+    namespace undef {
+        function test(x: any, stateObj: any): any;
+        function replace(n: any): number;
+        function revive(s: any): any;
+    }
+}
+declare const undef: ({
+    undef: {
+        test(x: any, stateObj: any): any;
+        replace(n: any): number;
+        revive(s: any): any;
+    };
+} | ({
+    sparseArrays: {
+        testPlainObjects: boolean;
+        test(x: any): boolean;
+        replace(a: any, stateObj: any): any;
+    };
+    sparseUndefined?: undefined;
+} | {
+    sparseUndefined: {
+        test(x: any, stateObj: any): boolean;
+        replace(n: any): number;
+        revive(s: any): undefined;
+    };
+    sparseArrays?: undefined;
+})[])[];
+export function unescapeKeyPathComponent(e: any): any;
+export const universal: {}[][];
+export namespace userObject {
+    namespace userObject {
+        function test(x: any, stateObj: any): any;
+        function replace(n: any): any;
+        function revive(s: any): any;
+    }
+}
+declare namespace IntlCollator {
+    function test(x: any): boolean;
+    function replace(c: any): any;
+    function revive(options: any): Intl.Collator;
+}
+declare namespace IntlDateTimeFormat {
+    function test(x: any): boolean;
+    function replace(dtf: any): any;
+    function revive(options: any): Intl.DateTimeFormat;
+}
+declare namespace IntlNumberFormat {
+    function test(x: any): boolean;
+    function replace(nf: any): any;
+    function revive(options: any): Intl.NumberFormat;
+}
+export { l as JSON_TYPES, u as Typeson, e as TypesonPromise, p as Undefined, expObj$1 as builtin, expObj as structuredCloning, typedArraysSocketIO as typedArraysSocketio, undef$1 as undef, undef as undefPreset };
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/typeson-registry/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../vendor/typeson-registry/dist/index.js"],"names":[],"mappings":"AAG4+U,wBAA4D;AAApiV,uBAAu3U;;;IAHvsN,0BAAgL;IAAC,mBAAuD;;AAGg+M,mBAAwE;AA49Bp8U;;;;;;;;;;;;;;;KA4DE;;;QAl8BM,+BAAqD;QACrD;;UAUC;QACD,8CAUC;;;;;QA0BD,+BAEC;;;;;;;QAlBD,sCAEC;;;QAED,uCAIC;;;;;QAuFD,+BAA8C;QAC9C;;;UAeC;QACD;;;iBAEC;QACD,mCAsBC;;;AAkzBT,6BAsBE;;;QAlyBM,2BAGC;QACD;;;UAKC;QACD;;;gBAIC;;;;;QAQD,2BAEC;QACD,qCAiBC;QACD;;;;+BAEC;;;;;QAMD,+BAAkD;QAClD;;;;;;;;;;;;;;UAcC;QACD,sDAaC;;;;;QAMD,+BAA8C;QAC9C,+BAMC;QACD,iCAKC;;;;;QAMD,+BAA+C;QAC/C;;;;;;;;;;;;;;;;UAMC;QACD,iCASC;;;AAMT,wBAAkB;AAxa2jK,oDAA4H;;;QAqejsK,+BAA8C;QAC9C;;;;;UAiBC;QACD;;;;;iBAKC;QACD,mCAwBC;;;;;;;QAOD,+BAAkD;QAClD,iCAMC;QACD;;;YAaQ;;;eAGG;;YAKH;;eAEG;;UAOV;;;AAnkB6zK,kDAAwN;AAA6L,yCAAmF;AAA90C,0DAAyU;;;QA2kBjyJ,2BAKC;QACD,kCAWC;QACD,2CAqBC;QACD,mDAUC;;;;;QAQD,+BAAmD;QACnD;;;;UAOC;QACD,mCAIC;;;;;QAMD,+BAAmD;QACnD,iCAAkC;QAClC,gCAA+C;;;;;;;;AA1pBi+J,sCAAqD;AAApS,+CAAuG;AAA9kB,gDAAyG;AAAqe,0CAAwI;;;QA0rBhhK,+BAA6C;QAC7C,iCAA0C;QAC1C,6CAA6C;;;;;QAM7C,+BAAoC;QACpC,iCAA6B;QAC7B,gCAAiC;;;;;QAMjC,+BAAmD;QACnD,iCAAmC;QACnC,gCAA+C;;;;;QAM/C,+BAEC;QACD,iCAGC;QACD,gCAEC;;;;;QAMD,2BAoBC;QACD,kCAEC;;;AAoWT,+BAGE;;;QA9VM,sCAEC;;;QAED,uCAAoC;;;QAIpC,sCAGC;;;QAED,wCAGC;;;QAID,sCAEC;;;QAED,uCAAoC;;;;;QAMpC,+BAAgD;QAChD;;;UASC;QACD;;;mBAA8D;;;;;QAU9D,2BAIC;QACD,yCAIC;QACD,mDAEC;;;;;QAMD,+BAA6C;QAC7C,iCAEC;QACD,uCAA2C;;;AA10B2+K,0DAA6L;AAimC3tL,4BAME;AAEF;;;;;;;;;;;;;;KAoBE;AAhGF;;;;;;;;;;;;;;;;;;;;;;;;KAKE;AA+FF,2BAoCE;AAIF,2CAyEG;AAlvCw6I,4CAAqD;AAy4Bh+I,6BAAuB;AAxDvB,sCAA+B;;;QAyHvB,0CAGC;QACD,iCAAyB;QACzB,6BAIC;;;AAiST;;;;;;;;;;;;;;;;;;;;QAGE;AAvvCusK,sDAA6H;AAyvCt0K,+BAIE;;;QApSM,0CAA8C;QAC9C,8BAA8B;QAC9B,6BAAwB;;;;IA5T5B,+BAAuD;IACvD,8BAA2C;IAC3C,6CAAuE;;;IAIvE,+BAA6D;IAC7D,gCAA+C;IAC/C,mDAEC;;;IAID,+BAA2D;IAC3D,+BAA6C;IAC7C,iDAA2E"}

package/dist/vendor-imports.d.ts

@@ -0,0 +1,3 @@
+export { jml, body, nbsp } from "jamilih";
+export { getJSONType, Typeson, unescapeKeyPathComponent, structuredCloningThrowing } from "typeson-registry";
+//# sourceMappingURL=vendor-imports.d.ts.map

package/dist/vendor-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor-imports.d.ts","sourceRoot":"","sources":["../src/vendor-imports.js"],"names":[],"mappings":""}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@es-joy/jsoe",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": "./src/index.js"
   },
@@ -16,33 +17,34 @@
   },
   "dependencies": {
     "@brettz9/node-static": "^0.1.1",
-    "jamilih": "0.55.2",
+    "jamilih": "0.56.0",
     "sceditor": "3.2.0",
-    "typeson-registry": "6.0.0"
+    "typeson-registry": "7.0.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.21.4",
-    "@babel/plugin-transform-modules-commonjs": "^7.21.2",
-    "@babel/preset-env": "^7.21.4",
+    "@babel/core": "^7.21.8",
+    "@babel/plugin-transform-modules-commonjs": "^7.21.5",
+    "@babel/preset-env": "^7.21.5",
     "@babel/register": "^7.21.0",
     "@brettz9/eslint-plugin": "^1.0.4",
     "@cypress/code-coverage": "^3.10.4",
     "@rollup/plugin-babel": "^6.0.3",
     "@rollup/plugin-commonjs": "^24.1.0",
     "@rollup/plugin-node-resolve": "^15.0.2",
+    "@types/jsdom": "^21.1.1",
     "axe-core": "^4.7.0",
-    "cypress": "^12.10.0",
+    "cypress": "^12.11.0",
     "cypress-axe": "^1.4.0",
     "eslint": "^8.39.0",
     "eslint-config-ash-nazg": "^34.11.1",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-array-func": "^3.1.8",
     "eslint-plugin-compat": "^4.1.4",
-    "eslint-plugin-cypress": "^2.13.2",
+    "eslint-plugin-cypress": "^2.13.3",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-html": "^7.1.0",
     "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-jsdoc": "^43.0.7",
+    "eslint-plugin-jsdoc": "^43.1.1",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-n": "^15.7.0",
     "eslint-plugin-no-unsanitized": "^4.0.2",
@@ -52,13 +54,15 @@
     "eslint-plugin-standard": "^4.1.0",
     "eslint-plugin-unicorn": "^46.0.0",
     "fast-deep-equal": "^3.1.3",
+    "jsdom": "^21.1.1",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
     "open-cli": "^7.2.0",
     "rimraf": "^5.0.0",
-    "rollup": "3.20.7",
+    "rollup": "3.21.4",
     "rollup-plugin-istanbul": "^4.0.0",
-    "rollup-plugin-node-builtins": "^2.1.2"
+    "rollup-plugin-node-builtins": "^2.1.2",
+    "typescript": "^5.0.4"
   },
   "repository": {
     "type": "git",
@@ -78,6 +82,7 @@
   "license": "MIT",
   "homepage": "https://github.com/es-joy/jsoe#readme",
   "scripts": {
+    "tsc": "tsc",
     "eslint": "eslint --ext=js,cjs,md,html .",
     "lint": "npm run eslint --",
     "coverage": "open-cli http://localhost:8087/coverage/lcov-report/",

package/postorder-traversal.js

@@ -0,0 +1,58 @@
+/* eslint-disable import/unambiguous -- Testing */
+
+/**
+ * @typedef {any} ArbitraryValue
+ */
+
+/**
+ * @param {ArbitraryValue} t
+ * @yields {ArbitraryValue}
+ * @returns {void}
+ */
+function * postorder (t) {
+  if (Array.isArray(t)) {
+    for (const child of t) {
+      yield * postorder(child);
+    }
+  } else {
+    for (const child of Object.values(t)) {
+      yield * postorder(child);
+    }
+  }
+  if (t !== null && typeof t === 'object' && !Array.isArray(t)) {
+    yield t;
+  }
+}
+
+const mytree = {
+  value: 1,
+  children: [
+    {
+      value: 2,
+      children: [{
+        value: 4,
+        children: []
+      }]
+    },
+    {
+      value: 3,
+      children: [
+        {
+          value: 5,
+          children: []
+        },
+        {
+          value: 6,
+          children: [
+            {
+              value: 7,
+              children: []
+            }
+          ]
+        }
+      ]
+    }
+  ]
+};
+
+console.log([...postorder(mytree)]);