@tonyclaw/agent-inspector 2.0.0

package/.output/server/_libs/hast-util-to-jsx-runtime.mjs

@@ -0,0 +1,388 @@
+import { s as stringify } from "./comma-separated-tokens.mjs";
+import { o as ok } from "./devlop.mjs";
+import { s as svg, h as html, f as find, a as hastToReact } from "./property-information.mjs";
+import { s as stringify$1 } from "./space-separated-tokens.mjs";
+import { s as styleToJs } from "./style-to-js.mjs";
+import { w as whitespace } from "./hast-util-whitespace.mjs";
+import { n as name } from "./estree-util-is-identifier-name.mjs";
+import { V as VFileMessage } from "./vfile-message.mjs";
+import { p as pointStart } from "./unist-util-position.mjs";
+const own = {}.hasOwnProperty;
+const emptyMap = /* @__PURE__ */ new Map();
+const cap = /[A-Z]/g;
+const tableElements = /* @__PURE__ */ new Set(["table", "tbody", "thead", "tfoot", "tr"]);
+const tableCellElement = /* @__PURE__ */ new Set(["td", "th"]);
+const docs = "https://github.com/syntax-tree/hast-util-to-jsx-runtime";
+function toJsxRuntime(tree, options) {
+  if (!options || options.Fragment === void 0) {
+    throw new TypeError("Expected `Fragment` in options");
+  }
+  const filePath = options.filePath || void 0;
+  let create;
+  if (options.development) {
+    if (typeof options.jsxDEV !== "function") {
+      throw new TypeError(
+        "Expected `jsxDEV` in options when `development: true`"
+      );
+    }
+    create = developmentCreate(filePath, options.jsxDEV);
+  } else {
+    if (typeof options.jsx !== "function") {
+      throw new TypeError("Expected `jsx` in production options");
+    }
+    if (typeof options.jsxs !== "function") {
+      throw new TypeError("Expected `jsxs` in production options");
+    }
+    create = productionCreate(filePath, options.jsx, options.jsxs);
+  }
+  const state = {
+    Fragment: options.Fragment,
+    ancestors: [],
+    components: options.components || {},
+    create,
+    elementAttributeNameCase: options.elementAttributeNameCase || "react",
+    evaluater: options.createEvaluater ? options.createEvaluater() : void 0,
+    filePath,
+    ignoreInvalidStyle: options.ignoreInvalidStyle || false,
+    passKeys: options.passKeys !== false,
+    passNode: options.passNode || false,
+    schema: options.space === "svg" ? svg : html,
+    stylePropertyNameCase: options.stylePropertyNameCase || "dom",
+    tableCellAlignToStyle: options.tableCellAlignToStyle !== false
+  };
+  const result = one(state, tree, void 0);
+  if (result && typeof result !== "string") {
+    return result;
+  }
+  return state.create(
+    tree,
+    state.Fragment,
+    { children: result || void 0 },
+    void 0
+  );
+}
+function one(state, node, key) {
+  if (node.type === "element") {
+    return element(state, node, key);
+  }
+  if (node.type === "mdxFlowExpression" || node.type === "mdxTextExpression") {
+    return mdxExpression(state, node);
+  }
+  if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
+    return mdxJsxElement(state, node, key);
+  }
+  if (node.type === "mdxjsEsm") {
+    return mdxEsm(state, node);
+  }
+  if (node.type === "root") {
+    return root(state, node, key);
+  }
+  if (node.type === "text") {
+    return text(state, node);
+  }
+}
+function element(state, node, key) {
+  const parentSchema = state.schema;
+  let schema = parentSchema;
+  if (node.tagName.toLowerCase() === "svg" && parentSchema.space === "html") {
+    schema = svg;
+    state.schema = schema;
+  }
+  state.ancestors.push(node);
+  const type = findComponentFromName(state, node.tagName, false);
+  const props = createElementProps(state, node);
+  let children = createChildren(state, node);
+  if (tableElements.has(node.tagName)) {
+    children = children.filter(function(child) {
+      return typeof child === "string" ? !whitespace(child) : true;
+    });
+  }
+  addNode(state, props, type, node);
+  addChildren(props, children);
+  state.ancestors.pop();
+  state.schema = parentSchema;
+  return state.create(node, type, props, key);
+}
+function mdxExpression(state, node) {
+  if (node.data && node.data.estree && state.evaluater) {
+    const program = node.data.estree;
+    const expression = program.body[0];
+    ok(expression.type === "ExpressionStatement");
+    return (
+      /** @type {Child | undefined} */
+      state.evaluater.evaluateExpression(expression.expression)
+    );
+  }
+  crashEstree(state, node.position);
+}
+function mdxEsm(state, node) {
+  if (node.data && node.data.estree && state.evaluater) {
+    return (
+      /** @type {Child | undefined} */
+      state.evaluater.evaluateProgram(node.data.estree)
+    );
+  }
+  crashEstree(state, node.position);
+}
+function mdxJsxElement(state, node, key) {
+  const parentSchema = state.schema;
+  let schema = parentSchema;
+  if (node.name === "svg" && parentSchema.space === "html") {
+    schema = svg;
+    state.schema = schema;
+  }
+  state.ancestors.push(node);
+  const type = node.name === null ? state.Fragment : findComponentFromName(state, node.name, true);
+  const props = createJsxElementProps(state, node);
+  const children = createChildren(state, node);
+  addNode(state, props, type, node);
+  addChildren(props, children);
+  state.ancestors.pop();
+  state.schema = parentSchema;
+  return state.create(node, type, props, key);
+}
+function root(state, node, key) {
+  const props = {};
+  addChildren(props, createChildren(state, node));
+  return state.create(node, state.Fragment, props, key);
+}
+function text(_, node) {
+  return node.value;
+}
+function addNode(state, props, type, node) {
+  if (typeof type !== "string" && type !== state.Fragment && state.passNode) {
+    props.node = node;
+  }
+}
+function addChildren(props, children) {
+  if (children.length > 0) {
+    const value = children.length > 1 ? children : children[0];
+    if (value) {
+      props.children = value;
+    }
+  }
+}
+function productionCreate(_, jsx, jsxs) {
+  return create;
+  function create(_2, type, props, key) {
+    const isStaticChildren = Array.isArray(props.children);
+    const fn = isStaticChildren ? jsxs : jsx;
+    return key ? fn(type, props, key) : fn(type, props);
+  }
+}
+function developmentCreate(filePath, jsxDEV) {
+  return create;
+  function create(node, type, props, key) {
+    const isStaticChildren = Array.isArray(props.children);
+    const point = pointStart(node);
+    return jsxDEV(
+      type,
+      props,
+      key,
+      isStaticChildren,
+      {
+        columnNumber: point ? point.column - 1 : void 0,
+        fileName: filePath,
+        lineNumber: point ? point.line : void 0
+      },
+      void 0
+    );
+  }
+}
+function createElementProps(state, node) {
+  const props = {};
+  let alignValue;
+  let prop;
+  for (prop in node.properties) {
+    if (prop !== "children" && own.call(node.properties, prop)) {
+      const result = createProperty(state, prop, node.properties[prop]);
+      if (result) {
+        const [key, value] = result;
+        if (state.tableCellAlignToStyle && key === "align" && typeof value === "string" && tableCellElement.has(node.tagName)) {
+          alignValue = value;
+        } else {
+          props[key] = value;
+        }
+      }
+    }
+  }
+  if (alignValue) {
+    const style = (
+      /** @type {Style} */
+      props.style || (props.style = {})
+    );
+    style[state.stylePropertyNameCase === "css" ? "text-align" : "textAlign"] = alignValue;
+  }
+  return props;
+}
+function createJsxElementProps(state, node) {
+  const props = {};
+  for (const attribute of node.attributes) {
+    if (attribute.type === "mdxJsxExpressionAttribute") {
+      if (attribute.data && attribute.data.estree && state.evaluater) {
+        const program = attribute.data.estree;
+        const expression = program.body[0];
+        ok(expression.type === "ExpressionStatement");
+        const objectExpression = expression.expression;
+        ok(objectExpression.type === "ObjectExpression");
+        const property = objectExpression.properties[0];
+        ok(property.type === "SpreadElement");
+        Object.assign(
+          props,
+          state.evaluater.evaluateExpression(property.argument)
+        );
+      } else {
+        crashEstree(state, node.position);
+      }
+    } else {
+      const name2 = attribute.name;
+      let value;
+      if (attribute.value && typeof attribute.value === "object") {
+        if (attribute.value.data && attribute.value.data.estree && state.evaluater) {
+          const program = attribute.value.data.estree;
+          const expression = program.body[0];
+          ok(expression.type === "ExpressionStatement");
+          value = state.evaluater.evaluateExpression(expression.expression);
+        } else {
+          crashEstree(state, node.position);
+        }
+      } else {
+        value = attribute.value === null ? true : attribute.value;
+      }
+      props[name2] = /** @type {Props[keyof Props]} */
+      value;
+    }
+  }
+  return props;
+}
+function createChildren(state, node) {
+  const children = [];
+  let index = -1;
+  const countsByName = state.passKeys ? /* @__PURE__ */ new Map() : emptyMap;
+  while (++index < node.children.length) {
+    const child = node.children[index];
+    let key;
+    if (state.passKeys) {
+      const name2 = child.type === "element" ? child.tagName : child.type === "mdxJsxFlowElement" || child.type === "mdxJsxTextElement" ? child.name : void 0;
+      if (name2) {
+        const count = countsByName.get(name2) || 0;
+        key = name2 + "-" + count;
+        countsByName.set(name2, count + 1);
+      }
+    }
+    const result = one(state, child, key);
+    if (result !== void 0) children.push(result);
+  }
+  return children;
+}
+function createProperty(state, prop, value) {
+  const info = find(state.schema, prop);
+  if (value === null || value === void 0 || typeof value === "number" && Number.isNaN(value)) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value = info.commaSeparated ? stringify(value) : stringify$1(value);
+  }
+  if (info.property === "style") {
+    let styleObject = typeof value === "object" ? value : parseStyle(state, String(value));
+    if (state.stylePropertyNameCase === "css") {
+      styleObject = transformStylesToCssCasing(styleObject);
+    }
+    return ["style", styleObject];
+  }
+  return [
+    state.elementAttributeNameCase === "react" && info.space ? hastToReact[info.property] || info.property : info.attribute,
+    value
+  ];
+}
+function parseStyle(state, value) {
+  try {
+    return styleToJs(value, { reactCompat: true });
+  } catch (error) {
+    if (state.ignoreInvalidStyle) {
+      return {};
+    }
+    const cause = (
+      /** @type {Error} */
+      error
+    );
+    const message = new VFileMessage("Cannot parse `style` attribute", {
+      ancestors: state.ancestors,
+      cause,
+      ruleId: "style",
+      source: "hast-util-to-jsx-runtime"
+    });
+    message.file = state.filePath || void 0;
+    message.url = docs + "#cannot-parse-style-attribute";
+    throw message;
+  }
+}
+function findComponentFromName(state, name$1, allowExpression) {
+  let result;
+  if (!allowExpression) {
+    result = { type: "Literal", value: name$1 };
+  } else if (name$1.includes(".")) {
+    const identifiers = name$1.split(".");
+    let index = -1;
+    let node;
+    while (++index < identifiers.length) {
+      const prop = name(identifiers[index]) ? { type: "Identifier", name: identifiers[index] } : { type: "Literal", value: identifiers[index] };
+      node = node ? {
+        type: "MemberExpression",
+        object: node,
+        property: prop,
+        computed: Boolean(index && prop.type === "Literal"),
+        optional: false
+      } : prop;
+    }
+    result = node;
+  } else {
+    result = name(name$1) && !/^[a-z]/.test(name$1) ? { type: "Identifier", name: name$1 } : { type: "Literal", value: name$1 };
+  }
+  if (result.type === "Literal") {
+    const name2 = (
+      /** @type {string | number} */
+      result.value
+    );
+    return own.call(state.components, name2) ? state.components[name2] : name2;
+  }
+  if (state.evaluater) {
+    return state.evaluater.evaluateExpression(result);
+  }
+  crashEstree(state);
+}
+function crashEstree(state, place) {
+  const message = new VFileMessage(
+    "Cannot handle MDX estrees without `createEvaluater`",
+    {
+      ancestors: state.ancestors,
+      place,
+      ruleId: "mdx-estree",
+      source: "hast-util-to-jsx-runtime"
+    }
+  );
+  message.file = state.filePath || void 0;
+  message.url = docs + "#cannot-handle-mdx-estrees-without-createevaluater";
+  throw message;
+}
+function transformStylesToCssCasing(domCasing) {
+  const cssCasing = {};
+  let from;
+  for (from in domCasing) {
+    if (own.call(domCasing, from)) {
+      cssCasing[transformStyleToCssCasing(from)] = domCasing[from];
+    }
+  }
+  return cssCasing;
+}
+function transformStyleToCssCasing(from) {
+  let to = from.replace(cap, toDash);
+  if (to.slice(0, 3) === "ms-") to = "-" + to;
+  return to;
+}
+function toDash($0) {
+  return "-" + $0.toLowerCase();
+}
+export {
+  toJsxRuntime as t
+};

package/.output/server/_libs/hast-util-whitespace.mjs

@@ -0,0 +1,10 @@
+const re = /[ \t\n\f\r]/g;
+function whitespace(thing) {
+  return typeof thing === "object" ? thing.type === "text" ? empty(thing.value) : false : empty(thing);
+}
+function empty(value) {
+  return value.replace(re, "") === "";
+}
+export {
+  whitespace as w
+};

package/.output/server/_libs/hookable.mjs

@@ -0,0 +1 @@
+

package/.output/server/_libs/html-url-attributes.mjs

@@ -0,0 +1,26 @@
+const urlAttributes = {
+  action: ["form"],
+  cite: ["blockquote", "del", "ins", "q"],
+  data: ["object"],
+  formAction: ["button", "input"],
+  href: ["a", "area", "base", "link"],
+  icon: ["menuitem"],
+  itemId: null,
+  manifest: ["html"],
+  ping: ["a", "area"],
+  poster: ["video"],
+  src: [
+    "audio",
+    "embed",
+    "iframe",
+    "img",
+    "input",
+    "script",
+    "source",
+    "track",
+    "video"
+  ]
+};
+export {
+  urlAttributes as u
+};

package/.output/server/_libs/immediate.mjs

@@ -0,0 +1,74 @@
+import { c as commonjsGlobal } from "./react.mjs";
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  var Mutation = commonjsGlobal.MutationObserver || commonjsGlobal.WebKitMutationObserver;
+  var scheduleDrain;
+  if (process.browser) {
+    if (Mutation) {
+      var called = 0;
+      var observer = new Mutation(nextTick);
+      var element = commonjsGlobal.document.createTextNode("");
+      observer.observe(element, {
+        characterData: true
+      });
+      scheduleDrain = function() {
+        element.data = called = ++called % 2;
+      };
+    } else if (!commonjsGlobal.setImmediate && typeof commonjsGlobal.MessageChannel !== "undefined") {
+      var channel = new commonjsGlobal.MessageChannel();
+      channel.port1.onmessage = nextTick;
+      scheduleDrain = function() {
+        channel.port2.postMessage(0);
+      };
+    } else if ("document" in commonjsGlobal && "onreadystatechange" in commonjsGlobal.document.createElement("script")) {
+      scheduleDrain = function() {
+        var scriptEl = commonjsGlobal.document.createElement("script");
+        scriptEl.onreadystatechange = function() {
+          nextTick();
+          scriptEl.onreadystatechange = null;
+          scriptEl.parentNode.removeChild(scriptEl);
+          scriptEl = null;
+        };
+        commonjsGlobal.document.documentElement.appendChild(scriptEl);
+      };
+    } else {
+      scheduleDrain = function() {
+        setTimeout(nextTick, 0);
+      };
+    }
+  } else {
+    scheduleDrain = function() {
+      process.nextTick(nextTick);
+    };
+  }
+  var draining;
+  var queue = [];
+  function nextTick() {
+    draining = true;
+    var i, oldQueue;
+    var len = queue.length;
+    while (len) {
+      oldQueue = queue;
+      queue = [];
+      i = -1;
+      while (++i < len) {
+        oldQueue[i]();
+      }
+      len = queue.length;
+    }
+    draining = false;
+  }
+  lib = immediate;
+  function immediate(task) {
+    if (queue.push(task) === 1 && !draining) {
+      scheduleDrain();
+    }
+  }
+  return lib;
+}
+export {
+  requireLib as r
+};

package/.output/server/_libs/inherits.mjs

@@ -0,0 +1,50 @@
+var inherits = { exports: {} };
+var inherits_browser = { exports: {} };
+var hasRequiredInherits_browser;
+function requireInherits_browser() {
+  if (hasRequiredInherits_browser) return inherits_browser.exports;
+  hasRequiredInherits_browser = 1;
+  if (typeof Object.create === "function") {
+    inherits_browser.exports = function inherits2(ctor, superCtor) {
+      if (superCtor) {
+        ctor.super_ = superCtor;
+        ctor.prototype = Object.create(superCtor.prototype, {
+          constructor: {
+            value: ctor,
+            enumerable: false,
+            writable: true,
+            configurable: true
+          }
+        });
+      }
+    };
+  } else {
+    inherits_browser.exports = function inherits2(ctor, superCtor) {
+      if (superCtor) {
+        ctor.super_ = superCtor;
+        var TempCtor = function() {
+        };
+        TempCtor.prototype = superCtor.prototype;
+        ctor.prototype = new TempCtor();
+        ctor.prototype.constructor = ctor;
+      }
+    };
+  }
+  return inherits_browser.exports;
+}
+var hasRequiredInherits;
+function requireInherits() {
+  if (hasRequiredInherits) return inherits.exports;
+  hasRequiredInherits = 1;
+  try {
+    var util = require("util");
+    if (typeof util.inherits !== "function") throw "";
+    inherits.exports = util.inherits;
+  } catch (e) {
+    inherits.exports = requireInherits_browser();
+  }
+  return inherits.exports;
+}
+export {
+  requireInherits as r
+};

package/.output/server/_libs/inline-style-parser.mjs

@@ -0,0 +1,142 @@
+var cjs;
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+  var NEWLINE_REGEX = /\n/g;
+  var WHITESPACE_REGEX = /^\s*/;
+  var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
+  var COLON_REGEX = /^:\s*/;
+  var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
+  var SEMICOLON_REGEX = /^[;\s]*/;
+  var TRIM_REGEX = /^\s+|\s+$/g;
+  var NEWLINE = "\n";
+  var FORWARD_SLASH = "/";
+  var ASTERISK = "*";
+  var EMPTY_STRING = "";
+  var TYPE_COMMENT = "comment";
+  var TYPE_DECLARATION = "declaration";
+  function index(style, options) {
+    if (typeof style !== "string") {
+      throw new TypeError("First argument must be a string");
+    }
+    if (!style) return [];
+    options = options || {};
+    var lineno = 1;
+    var column = 1;
+    function updatePosition(str) {
+      var lines = str.match(NEWLINE_REGEX);
+      if (lines) lineno += lines.length;
+      var i = str.lastIndexOf(NEWLINE);
+      column = ~i ? str.length - i : column + str.length;
+    }
+    function position() {
+      var start = { line: lineno, column };
+      return function(node) {
+        node.position = new Position(start);
+        whitespace();
+        return node;
+      };
+    }
+    function Position(start) {
+      this.start = start;
+      this.end = { line: lineno, column };
+      this.source = options.source;
+    }
+    Position.prototype.content = style;
+    function error(msg) {
+      var err = new Error(
+        options.source + ":" + lineno + ":" + column + ": " + msg
+      );
+      err.reason = msg;
+      err.filename = options.source;
+      err.line = lineno;
+      err.column = column;
+      err.source = style;
+      if (options.silent) ;
+      else {
+        throw err;
+      }
+    }
+    function match(re) {
+      var m = re.exec(style);
+      if (!m) return;
+      var str = m[0];
+      updatePosition(str);
+      style = style.slice(str.length);
+      return m;
+    }
+    function whitespace() {
+      match(WHITESPACE_REGEX);
+    }
+    function comments(rules) {
+      var c;
+      rules = rules || [];
+      while (c = comment()) {
+        if (c !== false) {
+          rules.push(c);
+        }
+      }
+      return rules;
+    }
+    function comment() {
+      var pos = position();
+      if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;
+      var i = 2;
+      while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
+        ++i;
+      }
+      i += 2;
+      if (EMPTY_STRING === style.charAt(i - 1)) {
+        return error("End of comment missing");
+      }
+      var str = style.slice(2, i - 2);
+      column += 2;
+      updatePosition(str);
+      style = style.slice(i);
+      column += 2;
+      return pos({
+        type: TYPE_COMMENT,
+        comment: str
+      });
+    }
+    function declaration() {
+      var pos = position();
+      var prop = match(PROPERTY_REGEX);
+      if (!prop) return;
+      comment();
+      if (!match(COLON_REGEX)) return error("property missing ':'");
+      var val = match(VALUE_REGEX);
+      var ret = pos({
+        type: TYPE_DECLARATION,
+        property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+        value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+      });
+      match(SEMICOLON_REGEX);
+      return ret;
+    }
+    function declarations() {
+      var decls = [];
+      comments(decls);
+      var decl;
+      while (decl = declaration()) {
+        if (decl !== false) {
+          decls.push(decl);
+          comments(decls);
+        }
+      }
+      return decls;
+    }
+    whitespace();
+    return declarations();
+  }
+  function trim(str) {
+    return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
+  }
+  cjs = index;
+  return cjs;
+}
+export {
+  requireCjs as r
+};

package/.output/server/_libs/is-plain-obj.mjs

@@ -0,0 +1,10 @@
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+export {
+  isPlainObject as i
+};