tape-six 0.9.0

package/src/deep6/traverse/assemble.js

@@ -0,0 +1,158 @@
+import {Env, Unifier, Variable} from '../unify.js';
+import walk, {
+  processOther,
+  processCircular,
+  processMap,
+  postMapCircular,
+  buildNewMap,
+  replaceObject,
+  processObject,
+  postObjectCircular,
+  getObjectData,
+  buildNewObject,
+  processVariable,
+  processCommand
+} from './walk.js';
+
+const empty = {};
+
+function postProcess(context) {
+  const stackOut = context.stackOut,
+    s = this.s,
+    {descriptors, keys} = getObjectData(s, context);
+  let j = stackOut.length - 1;
+  const result = keys.some(k => {
+    const d = descriptors[k];
+    if (d.get || d.set) return false;
+    const t = stackOut[j--];
+    return typeof t == 'number' && isNaN(t) ? typeof s[k] == 'number' && !isNaN(s[k]) : s[k] !== t;
+  });
+  if (result) {
+    buildNewObject(s, descriptors, keys, stackOut);
+  } else {
+    replaceObject(j, s, stackOut);
+  }
+}
+
+function postProcessSeen(context) {
+  const stackOut = context.stackOut,
+    s = this.s,
+    {descriptors, keys} = getObjectData(s, context);
+  let j = stackOut.length - 1;
+  const result = keys.some(k => {
+    const d = descriptors[k];
+    if (d.get || d.set) return false;
+    const t = stackOut[j--];
+    return typeof t == 'number' && isNaN(t) ? typeof s[k] == 'number' && !isNaN(s[k]) : s[k] !== t;
+  });
+  if (result) {
+    postObjectCircular(s, descriptors, keys, context);
+  } else {
+    replaceObject(j, s, stackOut);
+  }
+}
+
+const postProcessMap = context => {
+  const stackOut = context.stackOut,
+    s = this.s;
+  let j = stackOut.length - 1;
+  const result = Array.from(s.values()).some(v => {
+    const t = stackOut[j--];
+    return typeof t == 'number' && isNaN(t) ? typeof v == 'number' && !isNaN(v) : v !== t;
+  });
+  if (result) {
+    buildNewMap(s.keys(), stackOut);
+  } else {
+    replaceObject(j, s, stackOut);
+  }
+};
+
+function postProcessMapSeen(context) {
+  const stackOut = context.stackOut,
+    s = this.s;
+  let j = stackOut.length - 1;
+  const result = Array.from(s.values()).some(v => {
+    const t = stackOut[j--];
+    return typeof t == 'number' && isNaN(t) ? typeof v == 'number' && !isNaN(v) : v !== t;
+  });
+  if (result) {
+    postMapCircular(s, context);
+  } else {
+    replaceObject(j, s, stackOut);
+  }
+}
+
+const registry = [
+    walk.Command,
+    processCommand,
+    Array,
+    processObject(postProcess, postProcessSeen),
+    Variable,
+    processVariable,
+    Unifier,
+    processOther,
+    Date,
+    processOther,
+    RegExp,
+    processOther,
+    Map,
+    processMap(postProcessMap, postProcessMapSeen),
+    Set,
+    processOther,
+    Promise,
+    processOther
+  ],
+  filters = [];
+
+// add more types
+
+const addType = (Type, process) => registry.push(Type, process || processOther);
+
+typeof Int8Array == 'function' && addType(Int8Array);
+typeof Uint8Array == 'function' && addType(Uint8Array);
+typeof Uint8ClampedArray == 'function' && addType(Uint8ClampedArray);
+typeof Int16Array == 'function' && addType(Int16Array);
+typeof Uint16Array == 'function' && addType(Uint16Array);
+typeof Int32Array == 'function' && addType(Int32Array);
+typeof Uint32Array == 'function' && addType(Uint32Array);
+typeof Float32Array == 'function' && addType(Float32Array);
+typeof Float64Array == 'function' && addType(Float64Array);
+typeof BigInt64Array == 'function' && addType(BigInt64Array);
+typeof BigUint64Array == 'function' && addType(BigUint64Array);
+typeof DataView == 'function' && addType(DataView);
+typeof ArrayBuffer == 'function' && addType(ArrayBuffer);
+
+// main
+
+const assemble = (source, env, options) => {
+  if (env && !(env instanceof Env)) {
+    options = env;
+    env = null;
+  }
+  options = options || empty;
+
+  const context = options.context || {},
+    stackOut = [];
+  context.stackOut = stackOut;
+  context.env = env;
+
+  walk(source, {
+    processObject: options.processObject || processObject(postProcess, postProcessSeen),
+    processOther: options.processOther || processOther,
+    processCircular: options.processCircular || processCircular,
+    registry: options.registry || assemble.registry,
+    filters: options.filters || assemble.filters,
+    circular: options.circular,
+    symbols: options.symbols,
+    allProps: options.allProps,
+    context: context
+  });
+
+  // ice.assert(stackOut.length == 1);
+  return stackOut[0];
+};
+assemble.registry = registry;
+assemble.filters = filters;
+
+export {registry, filters};
+export default assemble;

package/src/deep6/traverse/clone.js

@@ -0,0 +1,109 @@
+import {Env, Unifier, Variable} from '../unify.js';
+import walk, {
+  processOther,
+  processCircular,
+  processMap,
+  postMapCircular,
+  buildNewMap,
+  processObject,
+  postObjectCircular,
+  getObjectData,
+  buildNewObject,
+  processVariable,
+  processCommand
+} from './walk.js';
+
+const empty = {};
+
+function postProcess(context) {
+  const {descriptors, keys} = getObjectData(this.s, context);
+  buildNewObject(this.s, descriptors, keys, context.stackOut);
+}
+
+function postProcessSeen(context) {
+  const {descriptors, keys} = getObjectData(this.s, context);
+  postObjectCircular(this.s, descriptors, keys, context);
+}
+
+function postProcessMap(context) {
+  buildNewMap(this.s.keys(), context.stackOut);
+}
+
+function postProcessMapSeen(context) {
+  postMapCircular(this.s, context);
+}
+
+const registry = [
+    walk.Command,
+    processCommand,
+    Array,
+    processObject(postProcess, postProcessSeen),
+    Variable,
+    processVariable,
+    Unifier,
+    processOther,
+    Date,
+    (val, context) => context.stackOut.push(new Date(val.getTime())),
+    RegExp,
+    (val, context) => context.stackOut.push(new RegExp(val.source, (val.global ? 'g' : '') + (val.multiline ? 'm' : '') + (val.ignoreCase ? 'i' : ''))),
+    Map,
+    processMap(postProcessMap, postProcessMapSeen),
+    Promise,
+    processOther
+  ],
+  filters = [];
+
+// add more types
+
+const addType = (Type, process) => registry.push(Type, process || ((val, context) => context.stackOut.push(new Type(val))));
+
+addType(Set);
+
+typeof Int8Array == 'function' && addType(Int8Array);
+typeof Uint8Array == 'function' && addType(Uint8Array);
+typeof Uint8ClampedArray == 'function' && addType(Uint8ClampedArray);
+typeof Int16Array == 'function' && addType(Int16Array);
+typeof Uint16Array == 'function' && addType(Uint16Array);
+typeof Int32Array == 'function' && addType(Int32Array);
+typeof Uint32Array == 'function' && addType(Uint32Array);
+typeof Float32Array == 'function' && addType(Float32Array);
+typeof Float64Array == 'function' && addType(Float64Array);
+typeof BigInt64Array == 'function' && addType(BigInt64Array);
+typeof BigUint64Array == 'function' && addType(BigUint64Array);
+typeof DataView == 'function' && addType(DataView);
+typeof ArrayBuffer == 'function' && addType(ArrayBuffer);
+
+// main
+
+const clone = (source, env, options) => {
+  if (env && !(env instanceof Env)) {
+    options = env;
+    env = null;
+  }
+  options = options || empty;
+
+  const context = options.context || {},
+    stackOut = [];
+  context.stackOut = stackOut;
+  context.env = env;
+
+  walk(source, {
+    processObject: options.processObject || processObject(postProcess, postProcessSeen),
+    processOther: options.processOther || processOther,
+    processCircular: options.processCircular || processCircular,
+    registry: options.registry || clone.registry,
+    filters: options.filters || clone.filters,
+    circular: options.circular,
+    symbols: options.symbols,
+    allProps: options.allProps,
+    context: context
+  });
+
+  // ice.assert(stackOut.length == 1);
+  return stackOut[0];
+};
+clone.registry = registry;
+clone.filters = filters;
+
+export {registry, filters};
+export default clone;

package/src/deep6/traverse/deref.js

@@ -0,0 +1,104 @@
+import {Env, Unifier, Variable} from '../unify.js';
+import walk, {processOther, processMap, replaceObject, processObject, getObjectData, processVariable, processCommand} from './walk.js';
+
+const empty = {};
+
+function postProcess(context) {
+  const stackOut = context.stackOut,
+    s = this.s,
+    {descriptors, keys} = getObjectData(s, context);
+  let j = stackOut.length - 1;
+  for (const key of keys) {
+    const d = descriptors[key];
+    if (!(d.get || d.set)) {
+      d.value = stackOut[j--];
+      Object.defineProperty(s, key, d);
+    }
+  }
+  replaceObject(j, s, stackOut);
+}
+
+function postProcessMap(context) {
+  const stackOut = context.stackOut,
+    s = this.s;
+  let j = stackOut.length - 1;
+  for (const key of s) {
+    s.set(key, stackOut[j--]);
+  }
+  replaceObject(j, s, stackOut);
+}
+
+const registry = [
+    walk.Command,
+    processCommand,
+    Array,
+    processObject(postProcess),
+    Variable,
+    processVariable,
+    Unifier,
+    processOther,
+    Date,
+    processOther,
+    RegExp,
+    processOther,
+    Map,
+    processMap(postProcessMap),
+    Set,
+    processOther,
+    Promise,
+    processOther
+  ],
+  filters = [];
+
+// add more types
+
+const addType = (Type, process) => registry.push(Type, process || processOther);
+
+typeof Int8Array == 'function' && addType(Int8Array);
+typeof Uint8Array == 'function' && addType(Uint8Array);
+typeof Uint8ClampedArray == 'function' && addType(Uint8ClampedArray);
+typeof Int16Array == 'function' && addType(Int16Array);
+typeof Uint16Array == 'function' && addType(Uint16Array);
+typeof Int32Array == 'function' && addType(Int32Array);
+typeof Uint32Array == 'function' && addType(Uint32Array);
+typeof Float32Array == 'function' && addType(Float32Array);
+typeof Float64Array == 'function' && addType(Float64Array);
+typeof BigInt64Array == 'function' && addType(BigInt64Array);
+typeof BigUint64Array == 'function' && addType(BigUint64Array);
+typeof DataView == 'function' && addType(DataView);
+typeof ArrayBuffer == 'function' && addType(ArrayBuffer);
+
+// main
+
+const deref = (source, env, options) => {
+  if (env && !(env instanceof Env)) {
+    options = env;
+    env = null;
+  }
+  options = options || empty;
+
+  const context = options.context || {},
+    stackOut = [];
+  context.stackOut = stackOut;
+  context.env = env;
+
+  walk(source, {
+    processObject: options.processObject || processObject(postProcess),
+    processOther: options.processOther || processOther,
+    processCircular: options.processCircular || processOther,
+    registry: options.registry || deref.registry,
+    filters: options.filters || deref.filters,
+    circular: options.circular,
+    symbols: options.symbols,
+    allProps: options.allProps,
+    context: context
+  });
+
+  // ice.assert(stackOut.length == 1);
+  return stackOut[0];
+};
+deref.registry = registry;
+deref.filters = filters;
+
+export {registry, filters};
+export default deref;

package/src/deep6/traverse/preprocess.js

@@ -0,0 +1,112 @@
+import {Unifier, Variable, open} from '../unify.js';
+import walk, {
+  processOther,
+  processCircular,
+  processMap,
+  postMapCircular,
+  buildNewMap,
+  processObject,
+  postObjectCircular,
+  getObjectData,
+  buildNewObject,
+  processCommand
+} from './walk.js';
+
+const empty = {};
+
+function postProcess(context) {
+  const {descriptors, keys} = getObjectData(this.s, context);
+  buildNewObject(this.s, descriptors, keys, context.stackOut, context[Array.isArray(this.s) ? 'wrapArray' : 'wrapObject']);
+}
+
+function postProcessSeen(context) {
+  const {descriptors, keys} = getObjectData(this.s, context);
+  postObjectCircular(this.s, descriptors, keys, context);
+}
+
+function postProcessMap(context) {
+  buildNewMap(this.s.keys(), context.stackOut, context.wrapMap);
+}
+
+function postProcessMapSeen(context) {
+  postMapCircular(this.s, context);
+}
+
+function processSet(val, context) {
+  const wrap = context.wrapSet;
+  context.stackOut.push(wrap ? wrap(new Set(val)) : val);
+}
+
+const registry = [
+    walk.Command,
+    processCommand,
+    Array,
+    processObject(postProcess, postProcessSeen),
+    Variable,
+    processOther,
+    Unifier,
+    processOther,
+    Date,
+    processOther,
+    RegExp,
+    processOther,
+    Map,
+    processMap(postProcessMap, postProcessMapSeen),
+    Set,
+    processSet,
+    Promise,
+    processOther
+  ],
+  filters = [];
+
+// add more types
+
+const addType = (Type, process) => registry.push(Type, process || processOther);
+
+typeof Int8Array == 'function' && addType(Int8Array);
+typeof Uint8Array == 'function' && addType(Uint8Array);
+typeof Uint8ClampedArray == 'function' && addType(Uint8ClampedArray);
+typeof Int16Array == 'function' && addType(Int16Array);
+typeof Uint16Array == 'function' && addType(Uint16Array);
+typeof Int32Array == 'function' && addType(Int32Array);
+typeof Uint32Array == 'function' && addType(Uint32Array);
+typeof Float32Array == 'function' && addType(Float32Array);
+typeof Float64Array == 'function' && addType(Float64Array);
+typeof BigInt64Array == 'function' && addType(BigInt64Array);
+typeof BigUint64Array == 'function' && addType(BigUint64Array);
+typeof DataView == 'function' && addType(DataView);
+typeof ArrayBuffer == 'function' && addType(ArrayBuffer);
+
+// main
+
+const preprocess = (source, options) => {
+  options = options || empty;
+
+  const context = options.context || {},
+    stackOut = [];
+  context.stackOut = stackOut;
+  context.wrapObject = options.openObjects && open;
+  context.wrapArray = options.openArrays && open;
+  context.wrapMap = options.openMaps && open;
+  context.wrapSet = options.openSets && open;
+
+  walk(source, {
+    processObject: options.processObject || processObject(postProcess, postProcessSeen),
+    processOther: options.processOther || processOther,
+    processCircular: options.processCircular || processCircular,
+    registry: options.registry || preprocess.registry,
+    filters: options.filters || preprocess.filters,
+    circular: options.circular,
+    symbols: options.symbols,
+    allProps: options.allProps,
+    context: context
+  });
+
+  // ice.assert(stackOut.length == 1);
+  return stackOut[0];
+};
+preprocess.registry = registry;
+preprocess.filters = filters;
+
+export {registry, filters};
+export default preprocess;