@easyv/biz-components 0.0.20 → 0.0.22

package/dist/node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/index.es.js

@@ -1,16 +1,25 @@
-import { bail as P } from "../../../../bail@2.0.2/node_modules/bail/index.es.js";
-import y from "../../../../extend@3.0.2/node_modules/extend/index.es.js";
-import z from "../../../../is-plain-obj@4.1.0/node_modules/is-plain-obj/index.es.js";
-import { CallableInstance as C } from "./callable-instance.es.js";
-import { trough as A } from "../../../../trough@2.2.0/node_modules/trough/lib/index.es.js";
-import { VFile as S } from "../../../../vfile@6.0.3/node_modules/vfile/lib/index.es.js";
-const F = {}.hasOwnProperty;
-class x extends C {
+import { bail } from "../../../../bail@2.0.2/node_modules/bail/index.es.js";
+import extend from "../../../../extend@3.0.2/node_modules/extend/index.es.js";
+import isPlainObject from "../../../../is-plain-obj@4.1.0/node_modules/is-plain-obj/index.es.js";
+import { CallableInstance } from "./callable-instance.es.js";
+import { trough } from "../../../../trough@2.2.0/node_modules/trough/lib/index.es.js";
+import { VFile } from "../../../../vfile@6.0.3/node_modules/vfile/lib/index.es.js";
+const own = {}.hasOwnProperty;
+class Processor extends CallableInstance {
   /**
    * Create a processor.
    */
   constructor() {
-    super("copy"), this.Compiler = void 0, this.Parser = void 0, this.attachers = [], this.compiler = void 0, this.freezeIndex = -1, this.frozen = void 0, this.namespace = {}, this.parser = void 0, this.transformers = A();
+    super("copy");
+    this.Compiler = void 0;
+    this.Parser = void 0;
+    this.attachers = [];
+    this.compiler = void 0;
+    this.freezeIndex = -1;
+    this.frozen = void 0;
+    this.namespace = {};
+    this.parser = void 0;
+    this.transformers = trough();
   }
   /**
    * Copy a processor.
@@ -24,16 +33,17 @@ class x extends C {
    *   affect the ancestral processor.
    */
   copy() {
-    const e = (
+    const destination = (
       /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */
-      new x()
+      new Processor()
     );
-    let n = -1;
-    for (; ++n < this.attachers.length; ) {
-      const t = this.attachers[n];
-      e.use(...t);
+    let index = -1;
+    while (++index < this.attachers.length) {
+      const attacher = this.attachers[index];
+      destination.use(...attacher);
     }
-    return e.data(y(!0, {}, this.namespace)), e;
+    destination.data(extend(true, {}, this.namespace));
+    return destination;
   }
   /**
    * Configure the processor with info available to all plugins.
@@ -94,8 +104,21 @@ class x extends C {
    *   The current processor when setting, the value at `key` when getting, or
    *   the entire dataset when getting without key.
    */
-  data(e, n) {
-    return typeof e == "string" ? arguments.length === 2 ? (b("data", this.frozen), this.namespace[e] = n, this) : F.call(this.namespace, e) && this.namespace[e] || void 0 : e ? (b("data", this.frozen), this.namespace = e, this) : this.namespace;
+  data(key, value) {
+    if (typeof key === "string") {
+      if (arguments.length === 2) {
+        assertUnfrozen("data", this.frozen);
+        this.namespace[key] = value;
+        return this;
+      }
+      return own.call(this.namespace, key) && this.namespace[key] || void 0;
+    }
+    if (key) {
+      assertUnfrozen("data", this.frozen);
+      this.namespace = key;
+      return this;
+    }
+    return this.namespace;
   }
   /**
    * Freeze a processor.
@@ -115,22 +138,30 @@ class x extends C {
    *   The current processor.
    */
   freeze() {
-    if (this.frozen)
+    if (this.frozen) {
       return this;
-    const e = (
+    }
+    const self = (
       /** @type {Processor} */
       /** @type {unknown} */
       this
     );
-    for (; ++this.freezeIndex < this.attachers.length; ) {
-      const [n, ...t] = this.attachers[this.freezeIndex];
-      if (t[0] === !1)
+    while (++this.freezeIndex < this.attachers.length) {
+      const [attacher, ...options] = this.attachers[this.freezeIndex];
+      if (options[0] === false) {
         continue;
-      t[0] === !0 && (t[0] = void 0);
-      const i = n.call(e, ...t);
-      typeof i == "function" && this.transformers.use(i);
+      }
+      if (options[0] === true) {
+        options[0] = void 0;
+      }
+      const transformer = attacher.call(self, ...options);
+      if (typeof transformer === "function") {
+        this.transformers.use(transformer);
+      }
     }
-    return this.frozen = !0, this.freezeIndex = Number.POSITIVE_INFINITY, this;
+    this.frozen = true;
+    this.freezeIndex = Number.POSITIVE_INFINITY;
+    return this;
   }
   /**
    * Parse text to a syntax tree.
@@ -146,10 +177,12 @@ class x extends C {
    * @returns {ParseTree extends undefined ? Node : ParseTree}
    *   Syntax tree representing `file`.
    */
-  parse(e) {
+  parse(file) {
     this.freeze();
-    const n = m(e), t = this.parser || this.Parser;
-    return w("parse", t), t(String(n), n);
+    const realFile = vfile(file);
+    const parser = this.parser || this.Parser;
+    assertParser("parse", parser);
+    return parser(String(realFile), realFile);
   }
   /**
    * Process the given file as configured on the processor.
@@ -193,31 +226,48 @@ class x extends C {
    *
    *   [rehype-react]: https://github.com/rehypejs/rehype-react
    */
-  process(e, n) {
-    const t = this;
-    return this.freeze(), w("process", this.parser || this.Parser), g("process", this.compiler || this.Compiler), n ? i(void 0, n) : new Promise(i);
-    function i(a, h) {
-      const p = m(e), l = (
+  process(file, done) {
+    const self = this;
+    this.freeze();
+    assertParser("process", this.parser || this.Parser);
+    assertCompiler("process", this.compiler || this.Compiler);
+    return done ? executor(void 0, done) : new Promise(executor);
+    function executor(resolve, reject) {
+      const realFile = vfile(file);
+      const parseTree = (
         /** @type {HeadTree extends undefined ? Node : HeadTree} */
         /** @type {unknown} */
-        t.parse(p)
+        self.parse(realFile)
       );
-      t.run(l, p, function(o, c, f) {
-        if (o || !c || !f)
-          return s(o);
-        const u = (
+      self.run(parseTree, realFile, function(error, tree, file2) {
+        if (error || !tree || !file2) {
+          return realDone(error);
+        }
+        const compileTree = (
           /** @type {CompileTree extends undefined ? Node : CompileTree} */
           /** @type {unknown} */
-          c
-        ), d = t.stringify(u, f);
-        D(d) ? f.value = d : f.result = d, s(
-          o,
+          tree
+        );
+        const compileResult = self.stringify(compileTree, file2);
+        if (looksLikeAValue(compileResult)) {
+          file2.value = compileResult;
+        } else {
+          file2.result = compileResult;
+        }
+        realDone(
+          error,
           /** @type {VFileWithOutput<CompileResult>} */
-          f
+          file2
         );
       });
-      function s(o, c) {
-        o || !c ? h(o) : a ? a(c) : n(void 0, c);
+      function realDone(error, file2) {
+        if (error || !file2) {
+          reject(error);
+        } else if (resolve) {
+          resolve(file2);
+        } else {
+          done(void 0, file2);
+        }
       }
     }
   }
@@ -252,11 +302,19 @@ class x extends C {
    *
    *   [rehype-react]: https://github.com/rehypejs/rehype-react
    */
-  processSync(e) {
-    let n = !1, t;
-    return this.freeze(), w("processSync", this.parser || this.Parser), g("processSync", this.compiler || this.Compiler), this.process(e, i), T("processSync", "process", n), t;
-    function i(a, h) {
-      n = !0, P(a), t = h;
+  processSync(file) {
+    let complete = false;
+    let result;
+    this.freeze();
+    assertParser("processSync", this.parser || this.Parser);
+    assertCompiler("processSync", this.compiler || this.Compiler);
+    this.process(file, realDone);
+    assertDone("processSync", "process", complete);
+    return result;
+    function realDone(error, file2) {
+      complete = true;
+      bail(error);
+      result = file2;
     }
   }
   /**
@@ -297,19 +355,30 @@ class x extends C {
    *   Otherwise, a promise rejected with a fatal error or resolved with the
    *   transformed tree.
    */
-  run(e, n, t) {
-    I(e), this.freeze();
-    const i = this.transformers;
-    return !t && typeof n == "function" && (t = n, n = void 0), t ? a(void 0, t) : new Promise(a);
-    function a(h, p) {
-      const l = m(n);
-      i.run(e, l, s);
-      function s(o, c, f) {
-        const u = (
+  run(tree, file, done) {
+    assertNode(tree);
+    this.freeze();
+    const transformers = this.transformers;
+    if (!done && typeof file === "function") {
+      done = file;
+      file = void 0;
+    }
+    return done ? executor(void 0, done) : new Promise(executor);
+    function executor(resolve, reject) {
+      const realFile = vfile(file);
+      transformers.run(tree, realFile, realDone);
+      function realDone(error, outputTree, file2) {
+        const resultingTree = (
           /** @type {TailTree extends undefined ? Node : TailTree} */
-          c || e
+          outputTree || tree
         );
-        o ? p(o) : h ? h(u) : t(void 0, u, f);
+        if (error) {
+          reject(error);
+        } else if (resolve) {
+          resolve(resultingTree);
+        } else {
+          done(void 0, resultingTree, file2);
+        }
       }
     }
   }
@@ -330,11 +399,16 @@ class x extends C {
    * @returns {TailTree extends undefined ? Node : TailTree}
    *   Transformed tree.
    */
-  runSync(e, n) {
-    let t = !1, i;
-    return this.run(e, n, a), T("runSync", "run", t), i;
-    function a(h, p) {
-      P(h), i = p, t = !0;
+  runSync(tree, file) {
+    let complete = false;
+    let result;
+    this.run(tree, file, realDone);
+    assertDone("runSync", "run", complete);
+    return result;
+    function realDone(error, tree2) {
+      bail(error);
+      result = tree2;
+      complete = true;
     }
   }
   /**
@@ -366,10 +440,13 @@ class x extends C {
    *
    *   [rehype-react]: https://github.com/rehypejs/rehype-react
    */
-  stringify(e, n) {
+  stringify(tree, file) {
     this.freeze();
-    const t = m(n), i = this.compiler || this.Compiler;
-    return g("stringify", i), I(e), i(e, t);
+    const realFile = vfile(file);
+    const compiler = this.compiler || this.Compiler;
+    assertCompiler("stringify", compiler);
+    assertNode(tree);
+    return compiler(tree, realFile);
   }
   /**
    * Configure the processor to use a plugin, a list of usable values, or a
@@ -428,103 +505,133 @@ class x extends C {
    * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
    *   Current processor.
    */
-  use(e, ...n) {
-    const t = this.attachers, i = this.namespace;
-    if (b("use", this.frozen), e != null) if (typeof e == "function")
-      l(e, n);
-    else if (typeof e == "object")
-      Array.isArray(e) ? p(e) : h(e);
-    else
-      throw new TypeError("Expected usable value, not `" + e + "`");
+  use(value, ...parameters) {
+    const attachers = this.attachers;
+    const namespace = this.namespace;
+    assertUnfrozen("use", this.frozen);
+    if (value === null || value === void 0) ;
+    else if (typeof value === "function") {
+      addPlugin(value, parameters);
+    } else if (typeof value === "object") {
+      if (Array.isArray(value)) {
+        addList(value);
+      } else {
+        addPreset(value);
+      }
+    } else {
+      throw new TypeError("Expected usable value, not `" + value + "`");
+    }
     return this;
-    function a(s) {
-      if (typeof s == "function")
-        l(s, []);
-      else if (typeof s == "object")
-        if (Array.isArray(s)) {
-          const [o, ...c] = (
+    function add(value2) {
+      if (typeof value2 === "function") {
+        addPlugin(value2, []);
+      } else if (typeof value2 === "object") {
+        if (Array.isArray(value2)) {
+          const [plugin, ...parameters2] = (
             /** @type {PluginTuple<Array<unknown>>} */
-            s
+            value2
           );
-          l(o, c);
-        } else
-          h(s);
-      else
-        throw new TypeError("Expected usable value, not `" + s + "`");
+          addPlugin(plugin, parameters2);
+        } else {
+          addPreset(value2);
+        }
+      } else {
+        throw new TypeError("Expected usable value, not `" + value2 + "`");
+      }
     }
-    function h(s) {
-      if (!("plugins" in s) && !("settings" in s))
+    function addPreset(result) {
+      if (!("plugins" in result) && !("settings" in result)) {
         throw new Error(
           "Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither"
         );
-      p(s.plugins), s.settings && (i.settings = y(!0, i.settings, s.settings));
+      }
+      addList(result.plugins);
+      if (result.settings) {
+        namespace.settings = extend(true, namespace.settings, result.settings);
+      }
     }
-    function p(s) {
-      let o = -1;
-      if (s != null) if (Array.isArray(s))
-        for (; ++o < s.length; ) {
-          const c = s[o];
-          a(c);
+    function addList(plugins) {
+      let index = -1;
+      if (plugins === null || plugins === void 0) ;
+      else if (Array.isArray(plugins)) {
+        while (++index < plugins.length) {
+          const thing = plugins[index];
+          add(thing);
         }
-      else
-        throw new TypeError("Expected a list of plugins, not `" + s + "`");
+      } else {
+        throw new TypeError("Expected a list of plugins, not `" + plugins + "`");
+      }
     }
-    function l(s, o) {
-      let c = -1, f = -1;
-      for (; ++c < t.length; )
-        if (t[c][0] === s) {
-          f = c;
+    function addPlugin(plugin, parameters2) {
+      let index = -1;
+      let entryIndex = -1;
+      while (++index < attachers.length) {
+        if (attachers[index][0] === plugin) {
+          entryIndex = index;
           break;
         }
-      if (f === -1)
-        t.push([s, ...o]);
-      else if (o.length > 0) {
-        let [u, ...d] = o;
-        const E = t[f][1];
-        z(E) && z(u) && (u = y(!0, E, u)), t[f] = [s, u, ...d];
+      }
+      if (entryIndex === -1) {
+        attachers.push([plugin, ...parameters2]);
+      } else if (parameters2.length > 0) {
+        let [primary, ...rest] = parameters2;
+        const currentPrimary = attachers[entryIndex][1];
+        if (isPlainObject(currentPrimary) && isPlainObject(primary)) {
+          primary = extend(true, currentPrimary, primary);
+        }
+        attachers[entryIndex] = [plugin, primary, ...rest];
       }
     }
   }
 }
-const R = new x().freeze();
-function w(r, e) {
-  if (typeof e != "function")
-    throw new TypeError("Cannot `" + r + "` without `parser`");
+const unified = new Processor().freeze();
+function assertParser(name, value) {
+  if (typeof value !== "function") {
+    throw new TypeError("Cannot `" + name + "` without `parser`");
+  }
 }
-function g(r, e) {
-  if (typeof e != "function")
-    throw new TypeError("Cannot `" + r + "` without `compiler`");
+function assertCompiler(name, value) {
+  if (typeof value !== "function") {
+    throw new TypeError("Cannot `" + name + "` without `compiler`");
+  }
 }
-function b(r, e) {
-  if (e)
+function assertUnfrozen(name, frozen) {
+  if (frozen) {
     throw new Error(
-      "Cannot call `" + r + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`."
+      "Cannot call `" + name + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`."
     );
+  }
 }
-function I(r) {
-  if (!z(r) || typeof r.type != "string")
-    throw new TypeError("Expected node, got `" + r + "`");
+function assertNode(node) {
+  if (!isPlainObject(node) || typeof node.type !== "string") {
+    throw new TypeError("Expected node, got `" + node + "`");
+  }
 }
-function T(r, e, n) {
-  if (!n)
+function assertDone(name, asyncName, complete) {
+  if (!complete) {
     throw new Error(
-      "`" + r + "` finished async. Use `" + e + "` instead"
+      "`" + name + "` finished async. Use `" + asyncName + "` instead"
     );
+  }
 }
-function m(r) {
-  return j(r) ? r : new S(r);
+function vfile(value) {
+  return looksLikeAVFile(value) ? value : new VFile(value);
 }
-function j(r) {
-  return !!(r && typeof r == "object" && "message" in r && "messages" in r);
+function looksLikeAVFile(value) {
+  return Boolean(
+    value && typeof value === "object" && "message" in value && "messages" in value
+  );
 }
-function D(r) {
-  return typeof r == "string" || L(r);
+function looksLikeAValue(value) {
+  return typeof value === "string" || isUint8Array(value);
 }
-function L(r) {
-  return !!(r && typeof r == "object" && "byteLength" in r && "byteOffset" in r);
+function isUint8Array(value) {
+  return Boolean(
+    value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
+  );
 }
 export {
-  x as Processor,
-  R as unified
+  Processor,
+  unified
 };
 //# sourceMappingURL=index.es.js.map