dSalieri · August 13, 2023 03:40
diff --git a/_index.md b/_index.md
diff --git a/index.js b/index.js
 function* createObjectIterator(obj, options) {
  const isRevealed = (value) => (typeof value === "object" && value !== null) || typeof value === "function";
  const is = (list) => {
    const toList = (v) => [...v[Symbol.iterator] && typeof v === "object" ? v : [v]];
    const isHandler = (v) => typeof v === "function";

    const A = toList(list);
    
    return {
      intersectWith(value){
        const B = !isHandler(value) ? new Set(toList(value)) : value;
        return A.some((v) => !isHandler(B) ? B.has(v) : B(v));
      },
      equalTo(value) {
        const B = toList(value);
        if (A.length !== B.length) return false;
        let i = A.length;
        while (i--) {
          if (!Object.is(A[i], B[i])) return false;
        }
        return true;
      }
    }
  };
  const getIterator = (obj) => new Set([...Reflect.ownKeys(obj), protoKey])[Symbol.iterator]();
  const sortOf = (arg) => Object.prototype.toString.call(arg).slice(8, -1).toLowerCase();
  const returnValue = (value) => {
    const aliaces = {
      true: "normal",
      false: "abrupt",
    };

    const list = {
      normal: {iterate: true, reveal: true},
      abrupt: {iterate: false, reveal: false},
      iterate: {reveal: false},
      reveal: {iterate: false},
    };

    return {...list.normal, ...list[aliaces[value] ?? value] ?? list.abrupt};
  };
  const descriptorWithType = (obj, prop) => {
    const desc = prop === protoKey ? {
        writable: false,
        enumerable: false,
        configurable: false,
        value: Reflect.getPrototypeOf(obj),
      } : Reflect.getOwnPropertyDescriptor(obj, prop);

    const result = { descriptor: desc, type: undefined };

    if (is(["writable", "value"]).intersectWith((v) => Reflect.has(desc, v))) result.type = "data";
    else if (is(["get", "set"]).intersectWith((v) => Reflect.has(desc, v))) result.type = "accessor";
  
    return result;
  };

  if (!isRevealed(obj)) {
    throw TypeError("Can't be iterable");
  }
  
  if (typeof options !== "function") {
    options = {
      mode: "permission",
      type: "both",
      proto: false,
      ...{
        ...options,
        reveal: {
          mode: "exclude",
          list: ["function"],
          ...options?.reveal,
        },
        flags: {
          ...options?.flags,
        },
      },
    };
  
    if (!is(["match", "permission"]).intersectWith(options.mode)) {
      throw TypeError("options.mode must be either 'match' or 'permission'");
    }
  
    if (options.mode === "permission" && is(Object.values(options.flags)).intersectWith((value) => typeof value === "boolean")) {
      throw TypeError("options.flags should have values either true or false (boolean value), because of options.mode that equal to 'permission'");
    }
  
    if (!is(["both", "data", "accessor"]).intersectWith(options.type)) {
      throw TypeError("options.type must be either 'both' or 'data' or 'accessor'");
    }
  
    if (!is([true, false, "iterate", "reveal", "only"]).intersectWith((value) => options.proto === value)) {
      throw TypeError("options.proto must be one of true, false, 'iterate', 'reveal' or 'only' values");
    }
  
    if (typeof options.reveal === "object") {
      if (!is(["exclude", "include"]).intersectWith((value) => options.reveal.mode === value)) {
        throw TypeError("options.reveal.mode must be either 'exclude' or 'include'");
      }
      if (!Array.isArray(options.reveal.list)) {
        throw TypeError("options.reveal.list must be an array type");
      }
    } else {
      throw TypeError("options.reveal must be an object type");
    }
  }

  const protoKey = Symbol("[[Prototype]]");

  const proxyOptions = {
    get() {
      const value = Reflect.get(...arguments);
      return isRevealed(value) ? new Proxy(value, this) : value;
    },
    set() {
      return false;
    },
    defineProperty() {
      return false;
    },
    deleteProperty() {
      return false;
    }
  };

  const traceStack = {
    main: [],
    proto: [],
    isProtoRevealed: false,
    __proto__: {
      get active(){
        return this.isProtoRevealed ? this.proto : this.main;
      }
    }
  };
  
  const proxy = new Proxy(obj, proxyOptions);

  const stack = [{
    name: "",
    node: obj,
    it: getIterator(obj),
  }];

  const nodes = new Set([obj]);

  while (true) {
    const last = stack.at(-1);
    if (last === undefined) break;

    let key;
    while ((key = last.it.next().value)) {
      const { type, descriptor } = descriptorWithType(last.node, key);
      const proxyDescriptor = new Proxy({type, ...descriptor}, proxyOptions);
      const parentNodeProxy = new Proxy(last.node, proxyOptions);
      const revealed = isRevealed(proxyDescriptor.value);

      const record = {
        descriptor: proxyDescriptor,
        key: protoKey === key ? protoKey.description : key,
        node: {
          parent: parentNodeProxy,
          current: revealed ? proxyDescriptor.value : null,
          ...revealed ? {isVisited: nodes.has(descriptor.value)} : {},
        },
        proto: {
          is: key === protoKey,
          isIn: traceStack.proto.length > 0,
        },
        trace: {
          main: [...traceStack.main],
          proto: [...traceStack.proto],
        },
      };
  
      const method = (value) => {
        return {
          function: () => {
            const condition = options.call(proxy, record);
            if (condition === "exit") return condition;
            return returnValue(condition) ?? returnValue("abrupt");
          },
          object: () => {
            if (key === protoKey) {
              if (options.proto === "only") return returnValue(true);
              return returnValue(options.proto);
            }

            if (options.proto === "only") return returnValue("abrupt");
  
            if (options.mode === "permission") {
              if (type === "data" && is(["both", "data"]).intersectWith(options.type)) {
                if (
                  is([options.flags.writable, descriptor.writable]).equalTo([false, false]) ||
                  is([options.flags.value, descriptor.value]).equalTo([false, undefined])
                ) return returnValue("abrupt");
              }
  
              if (type === "accessor" && is(["both", "accessor"]).intersectWith(options.type)) {
                if (
                  is([options.flags.set, descriptor.set]).equalTo([undefined, false]) || 
                  is([options.flags.get, descriptor.get]).equalTo([undefined, false])
                ) return returnValue("abrupt");
              }
  
              if (
                is([options.flags.enumerable, descriptor.enumerable]).equalTo([false, false]) || 
                is([options.flags.configurable, descriptor.configurable]).equalTo([false, false])
              ) return returnValue("abrupt");
            }
  
            if (options.mode === "match") {
              if (["both", type].every((value) => value !== options.type)) return returnValue("abrupt");
  
              if (!Object.entries(descriptor).every(([key, value]) => {
                  if (!Reflect.has(options.flags, key)) return true;
                  return Object.is(Reflect.get(options.flags, key), value);
                })) return returnValue("abrupt");
            }
  
            return returnValue("normal");
          },
        }[typeof value]();
      };
  
      const completion = method(options);
  
      if (completion === "exit") return;
      if (completion.iterate) yield record;
      if (!completion.reveal) continue;

      if (typeof options === "object" && key !== protoKey) {
        const listExpr = options.reveal.list.some((item) => sortOf(descriptor.value) === item);
        if (options.reveal.mode === "exclude" && listExpr) continue;
        if (options.reveal.mode === "include" && !listExpr) continue;
      }
  
      if (isRevealed(descriptor.value) && !nodes.has(descriptor.value)) {
        if (key === protoKey && !traceStack.isProtoRevealed) {
          traceStack.isProtoRevealed = true;
        }

        traceStack.active.push(protoKey === key ? protoKey.description : key);

        stack.push({
          name: key === protoKey ? protoKey : key,
          node: descriptor.value,
          it: getIterator(descriptor.value),
        });

        nodes.add(descriptor.value);

        break;
      }
    }

    if (key === undefined) {
      stack.pop();

      traceStack.active.pop();
      if (traceStack.proto.length === 0) {
        traceStack.isProtoRevealed = false;
      }
    }
  }
 }
	function* createObjectIterator(obj, options) {
	const isRevealed = (value) => (typeof value === "object" && value !== null) \|\| typeof value === "function";
	const is = (list) => {
	const toList = (v) => [...v[Symbol.iterator] && typeof v === "object" ? v : [v]];
	const isHandler = (v) => typeof v === "function";

	const A = toList(list);

	return {
	intersectWith(value){
	const B = !isHandler(value) ? new Set(toList(value)) : value;
	return A.some((v) => !isHandler(B) ? B.has(v) : B(v));
	},
	equalTo(value) {
	const B = toList(value);
	if (A.length !== B.length) return false;
	let i = A.length;
	while (i--) {
	if (!Object.is(A[i], B[i])) return false;
	}
	return true;
	}
	}
	};
	const getIterator = (obj) => new Set([...Reflect.ownKeys(obj), protoKey])[Symbol.iterator]();
	const sortOf = (arg) => Object.prototype.toString.call(arg).slice(8, -1).toLowerCase();
	const returnValue = (value) => {
	const aliaces = {
	true: "normal",
	false: "abrupt",
	};

	const list = {
	normal: {iterate: true, reveal: true},
	abrupt: {iterate: false, reveal: false},
	iterate: {reveal: false},
	reveal: {iterate: false},
	};

	return {...list.normal, ...list[aliaces[value] ?? value] ?? list.abrupt};
	};
	const descriptorWithType = (obj, prop) => {
	const desc = prop === protoKey ? {
	writable: false,
	enumerable: false,
	configurable: false,
	value: Reflect.getPrototypeOf(obj),
	} : Reflect.getOwnPropertyDescriptor(obj, prop);

	const result = { descriptor: desc, type: undefined };

	if (is(["writable", "value"]).intersectWith((v) => Reflect.has(desc, v))) result.type = "data";
	else if (is(["get", "set"]).intersectWith((v) => Reflect.has(desc, v))) result.type = "accessor";

	return result;
	};

	if (!isRevealed(obj)) {
	throw TypeError("Can't be iterable");
	}

	if (typeof options !== "function") {
	options = {
	mode: "permission",
	type: "both",
	proto: false,
	...{
	...options,
	reveal: {
	mode: "exclude",
	list: ["function"],
	...options?.reveal,
	},
	flags: {
	...options?.flags,
	},
	},
	};

	if (!is(["match", "permission"]).intersectWith(options.mode)) {
	throw TypeError("options.mode must be either 'match' or 'permission'");
	}

	if (options.mode === "permission" && is(Object.values(options.flags)).intersectWith((value) => typeof value === "boolean")) {
	throw TypeError("options.flags should have values either true or false (boolean value), because of options.mode that equal to 'permission'");
	}

	if (!is(["both", "data", "accessor"]).intersectWith(options.type)) {
	throw TypeError("options.type must be either 'both' or 'data' or 'accessor'");
	}

	if (!is([true, false, "iterate", "reveal", "only"]).intersectWith((value) => options.proto === value)) {
	throw TypeError("options.proto must be one of true, false, 'iterate', 'reveal' or 'only' values");
	}

	if (typeof options.reveal === "object") {
	if (!is(["exclude", "include"]).intersectWith((value) => options.reveal.mode === value)) {
	throw TypeError("options.reveal.mode must be either 'exclude' or 'include'");
	}
	if (!Array.isArray(options.reveal.list)) {
	throw TypeError("options.reveal.list must be an array type");
	}
	} else {
	throw TypeError("options.reveal must be an object type");
	}
	}

	const protoKey = Symbol("[[Prototype]]");

	const proxyOptions = {
	get() {
	const value = Reflect.get(...arguments);
	return isRevealed(value) ? new Proxy(value, this) : value;
	},
	set() {
	return false;
	},
	defineProperty() {
	return false;
	},
	deleteProperty() {
	return false;
	}
	};

	const traceStack = {
	main: [],
	proto: [],
	isProtoRevealed: false,
	__proto__: {
	get active(){
	return this.isProtoRevealed ? this.proto : this.main;
	}
	}
	};

	const proxy = new Proxy(obj, proxyOptions);

	const stack = [{
	name: "",
	node: obj,
	it: getIterator(obj),
	}];

	const nodes = new Set([obj]);

	while (true) {
	const last = stack.at(-1);
	if (last === undefined) break;

	let key;
	while ((key = last.it.next().value)) {
	const { type, descriptor } = descriptorWithType(last.node, key);
	const proxyDescriptor = new Proxy({type, ...descriptor}, proxyOptions);
	const parentNodeProxy = new Proxy(last.node, proxyOptions);
	const revealed = isRevealed(proxyDescriptor.value);

	const record = {
	descriptor: proxyDescriptor,
	key: protoKey === key ? protoKey.description : key,
	node: {
	parent: parentNodeProxy,
	current: revealed ? proxyDescriptor.value : null,
	...revealed ? {isVisited: nodes.has(descriptor.value)} : {},
	},
	proto: {
	is: key === protoKey,
	isIn: traceStack.proto.length > 0,
	},
	trace: {
	main: [...traceStack.main],
	proto: [...traceStack.proto],
	},
	};

	const method = (value) => {
	return {
	function: () => {
	const condition = options.call(proxy, record);
	if (condition === "exit") return condition;
	return returnValue(condition) ?? returnValue("abrupt");
	},
	object: () => {
	if (key === protoKey) {
	if (options.proto === "only") return returnValue(true);
	return returnValue(options.proto);
	}

	if (options.proto === "only") return returnValue("abrupt");

	if (options.mode === "permission") {
	if (type === "data" && is(["both", "data"]).intersectWith(options.type)) {
	if (
	is([options.flags.writable, descriptor.writable]).equalTo([false, false]) \|\|
	is([options.flags.value, descriptor.value]).equalTo([false, undefined])
	) return returnValue("abrupt");
	}

	if (type === "accessor" && is(["both", "accessor"]).intersectWith(options.type)) {
	if (
	is([options.flags.set, descriptor.set]).equalTo([undefined, false]) \|\|
	is([options.flags.get, descriptor.get]).equalTo([undefined, false])
	) return returnValue("abrupt");
	}

	if (
	is([options.flags.enumerable, descriptor.enumerable]).equalTo([false, false]) \|\|
	is([options.flags.configurable, descriptor.configurable]).equalTo([false, false])
	) return returnValue("abrupt");
	}

	if (options.mode === "match") {
	if (["both", type].every((value) => value !== options.type)) return returnValue("abrupt");

	if (!Object.entries(descriptor).every(([key, value]) => {
	if (!Reflect.has(options.flags, key)) return true;
	return Object.is(Reflect.get(options.flags, key), value);
	})) return returnValue("abrupt");
	}

	return returnValue("normal");
	},
	}[typeof value]();
	};

	const completion = method(options);

	if (completion === "exit") return;
	if (completion.iterate) yield record;
	if (!completion.reveal) continue;

	if (typeof options === "object" && key !== protoKey) {
	const listExpr = options.reveal.list.some((item) => sortOf(descriptor.value) === item);
	if (options.reveal.mode === "exclude" && listExpr) continue;
	if (options.reveal.mode === "include" && !listExpr) continue;
	}

	if (isRevealed(descriptor.value) && !nodes.has(descriptor.value)) {
	if (key === protoKey && !traceStack.isProtoRevealed) {
	traceStack.isProtoRevealed = true;
	}

	traceStack.active.push(protoKey === key ? protoKey.description : key);

	stack.push({
	name: key === protoKey ? protoKey : key,
	node: descriptor.value,
	it: getIterator(descriptor.value),
	});

	nodes.add(descriptor.value);

	break;
	}
	}

	if (key === undefined) {
	stack.pop();

	traceStack.active.pop();
	if (traceStack.proto.length === 0) {
	traceStack.isProtoRevealed = false;
	}
	}
	}
	}