@hamak/shared-utils 0.4.1

package/dist/es2015/core-utils-stack.js

@@ -0,0 +1,47 @@
+export function head(value) {
+    return { value };
+}
+export function push(head, value) {
+    return { value, parent: head };
+}
+export function concat(tail, stack) {
+    if (tail === undefined)
+        return stack;
+    if (stack === undefined)
+        return tail;
+    const { parent, value } = stack;
+    return { value, parent: concat(tail, parent) };
+}
+export function fromArray(t) {
+    return t === null || t === void 0 ? void 0 : t.reduce((acc, t) => push(acc, t), undefined);
+}
+export function reduce(head, reducer, initial) {
+    if (head === undefined) {
+        return initial;
+    }
+    const { parent, value } = head;
+    const acc = reduce(parent, reducer, initial);
+    return reducer(acc, value);
+}
+function equal(a, b) {
+    // Not equal if both are nullish
+    if (a === undefined || a === null || b === undefined || b === null) {
+        return false;
+    }
+    while (a !== undefined && b !== undefined) {
+        if (a.value !== b.value) {
+            return false;
+        }
+        a = a.parent;
+        b = b.parent;
+    }
+    // Equal if traversed all stack at both side
+    if ((a === undefined || a === null) && (b === undefined || b === null)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+const stack = { push, head, concat, reduce, fromArray, equal };
+export default stack;

package/dist/es2015/core-utils-types-hkt.js

@@ -0,0 +1 @@
+export {};

package/dist/es2015/core-utils-types.js

@@ -0,0 +1,39 @@
+export function holder(value) {
+    return { value };
+}
+export function hyper(data, children) {
+    return { data, children };
+}
+/**
+ * Utility function that create Overlay which mirror original object
+ * @param o
+ */
+export function hyperReflect(o) {
+    if (o === null || o === undefined) {
+        return hyper(o);
+    }
+    else if (Array.isArray(o)) {
+        return hyper(o, o.map(e => hyperReflect(e)));
+    }
+    else if (typeof o === "object") {
+        return hyper(o, Object.entries(o).reduce((acc, [k, v]) => (Object.assign(Object.assign({}, acc), { [k]: hyperReflect(v) })), {}));
+    }
+    else {
+        return hyper(o);
+    }
+}
+/**
+ * Mainly used to prevent re-entrant navitation
+ */
+export class ExplorationContext {
+    constructor(parent, values) {
+        this.parent = parent;
+        this.values = values;
+    }
+    explored(t) {
+        return this.values.includes(t);
+    }
+    newChild(values) {
+        return new ExplorationContext(this, values);
+    }
+}

package/dist/es2015/core-utils-validations.js

@@ -0,0 +1,18 @@
+class NoteUtils {
+    add(nv, ...notes) {
+        return Object.assign(Object.assign({}, (nv !== null && nv !== void 0 ? nv : { type: "core:node-validation" })), { notes });
+    }
+    of(...notes) {
+        return { type: "core:node-validation", notes };
+    }
+    info(key, message, params) {
+        return { severity: "info", key, message, params };
+    }
+    warning(key, message, params) {
+        return { severity: "warning", key, message, params };
+    }
+    error(key, message, params) {
+        return { severity: "error", key, message, params };
+    }
+}
+export const notes = new NoteUtils();

package/dist/es2015/core-utils.js

@@ -0,0 +1,113 @@
+function includes(arr, t) {
+    return arr === undefined ? false : arr.includes(t);
+}
+export function isNonNullObject(data) {
+    if (data === null || data === undefined) {
+        return false;
+    }
+    const dataType = typeof data;
+    return dataType === 'object' && !Array.isArray(data);
+}
+function isBlank(s) {
+    return s === null || s === undefined || s.trim() === "";
+}
+function isDefined(data) {
+    return data !== null && data !== undefined;
+}
+function isNotDefined(data) {
+    return !isDefined(data);
+}
+export function isNullish(o) {
+    return o === null || o === undefined;
+}
+export function isEmptyObject(object) {
+    for (const property in object) {
+        return false;
+    }
+    return true;
+}
+export function equalSet(a, b) {
+    return a.size === b.size && [...a].every((x) => b.has(x));
+}
+export const DEFAULT_EQUAL_FN = (a, b) => a === b;
+export function areSameDefined(a, b, equalFn) {
+    if (a === undefined || b === undefined) {
+        return false;
+    }
+    if (a === null || b === null) {
+        return false;
+    }
+    return a === b || (equalFn ? equalFn(a, b) : false);
+}
+/**
+ * Warning: non performant O(n2)
+ * @param arr
+ * @param equals
+ */
+export function removeDuplicates(arr, equals = DEFAULT_EQUAL_FN) {
+    return arr.filter((item, index) => arr.findIndex((e, i) => i < index && equals(item, e)) === -1);
+}
+// export function removeDuplicatesAndUndefined<T>(arr : (T|undefined)[], equals : EqualFn<T> = DEFAULT_EQUAL_FN) : T[] {
+//   return arr.filter((item, index) : item is T => item !== undefined && arr.findIndex((e,i) => i < index && equals(item, e)) === -1)
+// }
+function intersection(o1, o2) {
+    return Object.keys(o1).filter({}.hasOwnProperty.bind(o2));
+}
+function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 === null || obj2 === null || typeof obj1 !== 'object' || typeof obj2 !== 'object') {
+        return false;
+    }
+    if (Array.isArray(obj1) !== Array.isArray(obj2)) {
+        return false;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!keys2.includes(key)) {
+            return false;
+        }
+        if (!deepEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+function escapeForXPath(input) {
+    if (input.includes("'")) {
+        if (input.includes('"')) {
+            // Si la chaîne contient à la fois des guillemets simples et doubles
+            const parts = input.split("'");
+            return "concat(" + parts.map(part => `'${part}'`).join(", \"'\", ") + ")";
+        }
+        else {
+            // Si la chaîne ne contient que des guillemets simples
+            return `"${input}"`;
+        }
+    }
+    else {
+        // Si la chaîne ne contient que des guillemets doubles ou aucun guillemet
+        return `'${input}'`;
+    }
+}
+// TODO rename this function
+function cascadeFilter(arr, fns) {
+    if (arr.length === 0) {
+        return arr;
+    }
+    else {
+        for (const filterFn of fns) {
+            const filtered = arr.filter(filterFn);
+            if (filtered.length > 0) {
+                return filtered;
+            }
+        }
+        return arr;
+    }
+}
+export const utils = { includes, isNonNullObject, isEmptyObject, equalSet, isDefined, isBlank, isNotDefined, removeDuplicates, areSameDefined, intersection, deepEqual, escapeForXPath, cascadeFilter };

package/dist/es2015/index.js

@@ -0,0 +1,24 @@
+// Type utilities
+export * from './core-utils-types-hkt';
+export * from './core-utils-types';
+export { default } from './core-utils-stack';
+// Core utilities
+export { utils, DEFAULT_EQUAL_FN, removeDuplicates, areSameDefined } from './core-utils';
+// Resolvers
+export * from './core-utils-resolver';
+// Path and navigation utilities
+export * from './core-utils-pathway';
+export * from './core-utils-pathway-resolver';
+// Itinerary utilities
+export * from './itinerary/itinerary';
+export * from './itinerary/stack';
+// Note: HyperLayerNode is exported from core-utils-types (more complete version with HKT)
+// Filesystem utilities
+export * from './core-utils-filesystem';
+// Other utilities
+export * from './core-utils-file';
+export * from './core-utils-registry';
+export * from './core-utils-chrono';
+export * from './core-utils-comparator';
+export * from './core-utils-fqn';
+export * from './core-utils-validations';

package/dist/es2015/itinerary/hyper-layer-node.js

@@ -0,0 +1,21 @@
+export function hyper(data, children) {
+    return { data, children };
+}
+/**
+ * Utility function that create Overlay which mirror original object
+ * @param o
+ */
+export function hyperReflect(o) {
+    if (o === null || o === undefined) {
+        return hyper(o);
+    }
+    else if (Array.isArray(o)) {
+        return hyper(o, o.map(e => hyperReflect(e)));
+    }
+    else if (typeof o === "object") {
+        return hyper(o, Object.entries(o).reduce((acc, [k, v]) => (Object.assign(Object.assign({}, acc), { [k]: hyperReflect(v) })), {}));
+    }
+    else {
+        return hyper(o);
+    }
+}

package/dist/es2015/itinerary/itinerary.js

@@ -0,0 +1,276 @@
+import stack from "./stack";
+export function constructiveItinerary(steps) {
+    const segments = [];
+    const prototypes = [];
+    for (let i = 0; i < steps.length; i += 2) {
+        const segment = steps[i];
+        const prototype = steps[i + 1];
+        switch (typeof segment) {
+            case "string":
+            case "number":
+                {
+                    const step = typeof segment === "number" ? positionStep(segment) : propertyStep(segment);
+                    switch (typeof prototype) {
+                        case "object":
+                            { // including Array
+                                segments.push(segment);
+                                prototypes.push(prototype);
+                            }
+                            break;
+                        default: {
+                            throw new Error(`Expecting array or object but got : '${typeof prototype}'`);
+                        }
+                    }
+                }
+                break;
+            default: {
+                throw new Error(`Expecting string or number but gor : '${typeof segment}'`);
+            }
+        }
+    }
+    return {
+        itinerary: itineraryOf(...segments),
+        prototypes: stack.fromArray(prototypes)
+    };
+}
+export function areSameItineraryStep(step1, step2) {
+    var _a, _b, _c;
+    if (step1 == undefined || step2 == undefined) {
+        return false;
+    }
+    else if (step1.type !== step2.type) {
+        return false;
+    }
+    else {
+        switch (step1.type) {
+            case "property": return step2.type === "property" && step1.propertyName === step2.propertyName;
+            case "position": return step2.type === "position" && step1.position === step2.position;
+            case "lookup": {
+                return step2.type === "lookup"
+                    && ((_a = step1.keys) === null || _a === void 0 ? void 0 : _a.length) === ((_b = step2.keys) === null || _b === void 0 ? void 0 : _b.length)
+                    && ((_c = step1.keys) === null || _c === void 0 ? void 0 : _c.every(pv1 => step2.keys.some(pv2 => areSamePropertyValuePair(pv1, pv2))));
+            }
+        }
+    }
+}
+function areSamePropertyValuePair(p1, p2) {
+    return p1.propertyName === p2.propertyName
+        && p1.propertyValue === p2.propertyValue;
+}
+export function itineraryOf(...args) {
+    return args.reduce((parent, e) => {
+        const value = typeof e === 'string' ? propertyStep(e) : positionStep(e);
+        return { parent, value };
+    }, undefined);
+}
+const dataStep = propertyStep("data");
+const childrenStep = propertyStep("children");
+export function itineraryOverlay(it) {
+    return { value: dataStep, parent: itineraryOverlayInner(it) };
+}
+function itineraryOverlayInner(it) {
+    if (it === undefined) {
+        return undefined;
+    }
+    else {
+        const { value, parent } = it;
+        return { value, parent: { value: childrenStep, parent: itineraryOverlayInner(parent) } };
+    }
+}
+export function itineraryToStepArray(itinerary) {
+    let itn = itinerary;
+    const result = [];
+    while (itn !== undefined) {
+        result.push(itn.value);
+        itn = itn.parent;
+    }
+    return result.reverse();
+}
+export function propertyStep(propertyName) {
+    return { type: "property", propertyName };
+}
+export function positionStep(position) {
+    return { type: "position", position };
+}
+export function lookupStep(criteria) {
+    return { type: "lookup", keys: Object.entries(criteria).map(([k, v]) => ({ propertyName: k, propertyValue: v })) };
+}
+export function xpathFromStack(path) {
+    if (path === undefined) {
+        return ''; // TODO may need to return '.' here, to be checked
+    }
+    else {
+        const { value, parent } = path;
+        const parentXPath = xpathFromStack(parent);
+        switch (value.type) {
+            case 'property': {
+                return `${parentXPath}/${value.propertyName}`;
+            }
+            case 'position': {
+                return `${parentXPath}/*[${value.position + 1}]`;
+            }
+            case 'lookup': {
+                const predicate = value.keys.map(({ propertyName, propertyValue }) => `${propertyName}=$${propertyName}`).join(' and ');
+                return `${parentXPath}/*[${predicate}]`;
+            }
+        }
+    }
+}
+export function navigate(from, itinerary, prototype) {
+    if (from === undefined) {
+        return undefined;
+    }
+    if (itinerary === undefined) {
+        return from;
+    }
+    const { parent, value: step } = itinerary;
+    const current = navigate(from, parent, prototype === null || prototype === void 0 ? void 0 : prototype.parent);
+    return navigateStep(current, step, prototype === null || prototype === void 0 ? void 0 : prototype.value);
+}
+export function navigateStep(from, step, prototype) {
+    if (from === undefined) {
+        return undefined;
+    }
+    if (step === undefined) {
+        return from;
+    }
+    if (Array.isArray(from)) {
+        if (step.type === 'lookup') {
+            const stp = step;
+            const result = from.find(e => e !== undefined && stp.keys.every(({ propertyName, propertyValue }) => e[propertyName] === propertyValue));
+            if (result === undefined && prototype !== undefined) {
+                from.push(prototype);
+                return prototype;
+            }
+            else {
+                return result;
+            }
+        }
+        else if (step.type === 'position') {
+            const result = from[step.position];
+            if (result === undefined && prototype !== undefined) {
+                from[step.position] = prototype;
+                return prototype;
+            }
+            else {
+                return result;
+            }
+        }
+    }
+    else if (typeof from === 'object') {
+        if (step.type === 'property') {
+            const result = from === null ? undefined : from[step.propertyName];
+            if (result === undefined && prototype !== undefined && from !== null && from !== undefined) {
+                from[step.propertyName] = prototype;
+                return prototype;
+            }
+            else {
+                return result;
+            }
+        }
+    }
+    return undefined;
+}
+export function navigationDepth(from, itinerary, originalPath = xpathFromStack(itinerary)) {
+    if (from === undefined || from === null) {
+        return { value: undefined, path: '', originalPath };
+    }
+    if (itinerary === undefined) {
+        return { value: from, path: '', originalPath };
+    }
+    const { parent, value: step } = itinerary;
+    const current = navigationDepth(from, parent, originalPath);
+    if (current.value === undefined || current.value === null) {
+        return current;
+    }
+    const next = navigateStep(current.value, step);
+    if (next === undefined || next === null) {
+        return { value: current.value, path: xpathFromStack(parent), originalPath };
+    }
+    else {
+        return { value: next, path: xpathFromStack(itinerary), originalPath };
+    }
+}
+class OverlayNavigator {
+    navigate(from, itinerary) {
+        if (from === undefined) {
+            return undefined;
+        }
+        if (itinerary === undefined) {
+            return from;
+        }
+        const { parent, value: step } = itinerary;
+        const current = this.navigate(from, parent);
+        return current === undefined ? undefined : this.navigateStep(current, step);
+    }
+    navigateStep(from, step) {
+        if (from === undefined) {
+            return undefined;
+        }
+        if (step === undefined) {
+            return from;
+        }
+        if (Array.isArray(from.children)) {
+            if (step.type === 'lookup') {
+                const stp = step;
+                const result = from.children.find(e => e !== undefined && stp.keys.every(({ propertyName, propertyValue }) => { var _a; return ((_a = e.keys) === null || _a === void 0 ? void 0 : _a[propertyName]) === propertyValue; }));
+                return result;
+            }
+            else if (step.type === 'position') {
+                const result = from.children[step.position];
+                return result;
+            }
+        }
+        else if (from.children !== null && typeof from.children === 'object') {
+            if (step.type === 'property') {
+                const result = from === null ? undefined : from.children[step.propertyName];
+                return result;
+            }
+        }
+        return undefined;
+    }
+}
+export const overlayNavigator = new OverlayNavigator();
+/**
+ * Same as {navigate} but try to path missing data node using prototype parameter
+ * @param from
+ * @param itinerary
+ * @param prototype
+ */
+export function ensurePath(from, itinerary, prototype) {
+    return navigate(from, itinerary, prototype);
+}
+class AbstractPointerBuilder {
+    constructor() {
+        this.itinerary = [];
+    }
+    child(propertyName) {
+        this.itinerary.push({ type: "property", propertyName });
+        return this;
+    }
+    lookup(...criterion) {
+        criterion.forEach(([propertyName, propertyValue]) => {
+            this.itinerary.push({ type: "lookup", keys: [{ propertyName, propertyValue }] });
+        });
+    }
+}
+class RelativePointerBuilder extends AbstractPointerBuilder {
+    constructor(originUuid) {
+        super();
+        this.originUuid = originUuid;
+        this.type = "relative";
+    }
+}
+class AbsolutePointerBuilder extends AbstractPointerBuilder {
+    constructor() {
+        super();
+        this.type = "absolute";
+    }
+}
+export function pointer(fromId) {
+    if (fromId === undefined) {
+        return new AbsolutePointerBuilder();
+    }
+    return new RelativePointerBuilder(fromId);
+}
+export const ROOT = Object.freeze({ type: "absolute", itinerary: [] });

package/dist/es2015/itinerary/stack.js

@@ -0,0 +1,47 @@
+export function head(value) {
+    return { value };
+}
+export function push(head, value) {
+    return { value, parent: head };
+}
+export function concat(tail, stack) {
+    if (tail === undefined)
+        return stack;
+    if (stack === undefined)
+        return tail;
+    const { parent, value } = stack;
+    return { value, parent: concat(tail, parent) };
+}
+export function fromArray(t) {
+    return t === null || t === void 0 ? void 0 : t.reduce((acc, t) => push(acc, t), undefined);
+}
+export function reduce(head, reducer, initial) {
+    if (head === undefined) {
+        return initial;
+    }
+    const { parent, value } = head;
+    const acc = reduce(parent, reducer, initial);
+    return reducer(acc, value);
+}
+function equal(a, b) {
+    // Not equal if both are nullish
+    if (a === undefined || a === null || b === undefined || b === null) {
+        return false;
+    }
+    while (a !== undefined && b !== undefined) {
+        if (a.value !== b.value) {
+            return false;
+        }
+        a = a.parent;
+        b = b.parent;
+    }
+    // Equal if traversed all stack at both side
+    if ((a === undefined || a === null) && (b === undefined || b === null)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+const stack = { push, head, concat, reduce, fromArray, equal };
+export default stack;

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from './core-utils-types-hkt';
+export * from './core-utils-types';
+export type { StackElement } from './core-utils-stack';
+export { default } from './core-utils-stack';
+export { utils, DEFAULT_EQUAL_FN, removeDuplicates, areSameDefined } from './core-utils';
+export type { EqualFn } from './core-utils';
+export * from './core-utils-resolver';
+export * from './core-utils-pathway';
+export * from './core-utils-pathway-resolver';
+export * from './itinerary/itinerary';
+export * from './itinerary/stack';
+export * from './core-utils-filesystem';
+export * from './core-utils-file';
+export * from './core-utils-registry';
+export * from './core-utils-chrono';
+export * from './core-utils-comparator';
+export * from './core-utils-fqn';
+export * from './core-utils-validations';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAGnC,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAG7C,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACzF,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,uBAAuB,CAAC;AAGtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC;AAG9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAIlC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+// Type utilities
+export * from './core-utils-types-hkt';
+export * from './core-utils-types';
+export { default } from './core-utils-stack';
+// Core utilities
+export { utils, DEFAULT_EQUAL_FN, removeDuplicates, areSameDefined } from './core-utils';
+// Resolvers
+export * from './core-utils-resolver';
+// Path and navigation utilities
+export * from './core-utils-pathway';
+export * from './core-utils-pathway-resolver';
+// Itinerary utilities
+export * from './itinerary/itinerary';
+export * from './itinerary/stack';
+// Note: HyperLayerNode is exported from core-utils-types (more complete version with HKT)
+// Filesystem utilities
+export * from './core-utils-filesystem';
+// Other utilities
+export * from './core-utils-file';
+export * from './core-utils-registry';
+export * from './core-utils-chrono';
+export * from './core-utils-comparator';
+export * from './core-utils-fqn';
+export * from './core-utils-validations';

package/dist/itinerary/hyper-layer-node.d.ts

@@ -0,0 +1,12 @@
+export interface HyperLayerNode<T> {
+    keys?: Record<PropertyKey, any>;
+    data?: T;
+    children?: Record<string, HyperLayerNode<T>> | Array<HyperLayerNode<T>>;
+}
+export declare function hyper<T>(data: T, children?: Record<string, HyperLayerNode<T>> | Array<HyperLayerNode<T>>): HyperLayerNode<T>;
+/**
+ * Utility function that create Overlay which mirror original object
+ * @param o
+ */
+export declare function hyperReflect(o: any): HyperLayerNode<any>;
+//# sourceMappingURL=hyper-layer-node.d.ts.map

package/dist/itinerary/hyper-layer-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyper-layer-node.d.ts","sourceRoot":"","sources":["../../src/itinerary/hyper-layer-node.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,CAAA;IAC/B,IAAI,CAAC,EAAG,CAAC,CAAA;IACT,QAAQ,CAAC,EAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;CACzE;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,GAAI,cAAc,CAAC,CAAC,CAAC,CAE9H;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAG,GAAG,GAAI,cAAc,CAAC,GAAG,CAAC,CAU1D"}

package/dist/itinerary/hyper-layer-node.js

@@ -0,0 +1,21 @@
+export function hyper(data, children) {
+    return { data, children };
+}
+/**
+ * Utility function that create Overlay which mirror original object
+ * @param o
+ */
+export function hyperReflect(o) {
+    if (o === null || o === undefined) {
+        return hyper(o);
+    }
+    else if (Array.isArray(o)) {
+        return hyper(o, o.map(e => hyperReflect(e)));
+    }
+    else if (typeof o === "object") {
+        return hyper(o, Object.entries(o).reduce((acc, [k, v]) => ({ ...acc, [k]: hyperReflect(v) }), {}));
+    }
+    else {
+        return hyper(o);
+    }
+}