@cfp-studio/iframe 18.0.0

package/preview/__previewjs_internal__/object-inspect.js

@@ -0,0 +1,668 @@
+// Source: https://github.com/inspect-js/object-inspect
+// MIT License
+// Copyright (c) 2013 James Halliday
+
+var hasMap = typeof Map === "function" && Map.prototype;
+var mapSizeDescriptor =
+  Object.getOwnPropertyDescriptor && hasMap
+    ? Object.getOwnPropertyDescriptor(Map.prototype, "size")
+    : null;
+var mapSize =
+  hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function"
+    ? mapSizeDescriptor.get
+    : null;
+var mapForEach = hasMap && Map.prototype.forEach;
+var hasSet = typeof Set === "function" && Set.prototype;
+var setSizeDescriptor =
+  Object.getOwnPropertyDescriptor && hasSet
+    ? Object.getOwnPropertyDescriptor(Set.prototype, "size")
+    : null;
+var setSize =
+  hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function"
+    ? setSizeDescriptor.get
+    : null;
+var setForEach = hasSet && Set.prototype.forEach;
+var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
+var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
+var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
+var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
+var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
+var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
+var booleanValueOf = Boolean.prototype.valueOf;
+var objectToString = Object.prototype.toString;
+var functionToString = Function.prototype.toString;
+var $match = String.prototype.match;
+var $slice = String.prototype.slice;
+var $replace = String.prototype.replace;
+var $toUpperCase = String.prototype.toUpperCase;
+var $toLowerCase = String.prototype.toLowerCase;
+var $test = RegExp.prototype.test;
+var $concat = Array.prototype.concat;
+var $join = Array.prototype.join;
+var $arrSlice = Array.prototype.slice;
+var $floor = Math.floor;
+var bigIntValueOf =
+  typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
+var gOPS = Object.getOwnPropertySymbols;
+var symToString =
+  typeof Symbol === "function" && typeof Symbol.iterator === "symbol"
+    ? Symbol.prototype.toString
+    : null;
+var hasShammedSymbols =
+  typeof Symbol === "function" && typeof Symbol.iterator === "object";
+// ie, `has-tostringtag/shams
+var toStringTag =
+  typeof Symbol === "function" &&
+  Symbol.toStringTag &&
+  (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol")
+    ? Symbol.toStringTag
+    : null;
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var gPO =
+  (typeof Reflect === "function"
+    ? Reflect.getPrototypeOf
+    : Object.getPrototypeOf) ||
+  ([].__proto__ === Array.prototype // eslint-disable-line no-proto
+    ? function (O) {
+        return O.__proto__; // eslint-disable-line no-proto
+      }
+    : null);
+
+function addNumericSeparator(num, str) {
+  if (
+    num === Infinity ||
+    num === -Infinity ||
+    num !== num ||
+    (num && num > -1000 && num < 1000) ||
+    $test.call(/e/, str)
+  ) {
+    return str;
+  }
+  var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
+  if (typeof num === "number") {
+    var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)
+    if (int !== num) {
+      var intStr = String(int);
+      var dec = $slice.call(str, intStr.length + 1);
+      return (
+        $replace.call(intStr, sepRegex, "$&_") +
+        "." +
+        $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "")
+      );
+    }
+  }
+  return $replace.call(str, sepRegex, "$&_");
+}
+
+export default function inspect_(obj, options, depth, seen) {
+  var opts = options || {};
+
+  if (
+    has(opts, "quoteStyle") &&
+    opts.quoteStyle !== "single" &&
+    opts.quoteStyle !== "double"
+  ) {
+    throw new TypeError('option "quoteStyle" must be "single" or "double"');
+  }
+  if (
+    has(opts, "maxStringLength") &&
+    (typeof opts.maxStringLength === "number"
+      ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
+      : opts.maxStringLength !== null)
+  ) {
+    throw new TypeError(
+      'option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`'
+    );
+  }
+  var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
+  if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
+    throw new TypeError(
+      "option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`"
+    );
+  }
+
+  if (
+    has(opts, "indent") &&
+    opts.indent !== null &&
+    opts.indent !== "\t" &&
+    !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
+  ) {
+    throw new TypeError(
+      'option "indent" must be "\\t", an integer > 0, or `null`'
+    );
+  }
+  if (
+    has(opts, "numericSeparator") &&
+    typeof opts.numericSeparator !== "boolean"
+  ) {
+    throw new TypeError(
+      'option "numericSeparator", if provided, must be `true` or `false`'
+    );
+  }
+  var numericSeparator = opts.numericSeparator;
+
+  if (typeof obj === "undefined") {
+    return "undefined";
+  }
+  if (obj === null) {
+    return "null";
+  }
+  if (typeof obj === "boolean") {
+    return obj ? "true" : "false";
+  }
+
+  if (typeof obj === "string") {
+    return inspectString(obj, opts);
+  }
+  if (typeof obj === "number") {
+    if (obj === 0) {
+      return Infinity / obj > 0 ? "0" : "-0";
+    }
+    var str = String(obj);
+    return numericSeparator ? addNumericSeparator(obj, str) : str;
+  }
+  if (typeof obj === "bigint") {
+    var bigIntStr = String(obj) + "n";
+    return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
+  }
+
+  var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
+  if (typeof depth === "undefined") {
+    depth = 0;
+  }
+  if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
+    return isArray(obj) ? "[Array]" : "[Object]";
+  }
+
+  var indent = getIndent(opts, depth);
+
+  if (typeof seen === "undefined") {
+    seen = [];
+  } else if (indexOf(seen, obj) >= 0) {
+    return "[Circular]";
+  }
+
+  function inspect(value, from, noIndent) {
+    if (from) {
+      seen = $arrSlice.call(seen);
+      seen.push(from);
+    }
+    if (noIndent) {
+      var newOpts = {
+        depth: opts.depth,
+      };
+      if (has(opts, "quoteStyle")) {
+        newOpts.quoteStyle = opts.quoteStyle;
+      }
+      return inspect_(value, newOpts, depth + 1, seen);
+    }
+    return inspect_(value, opts, depth + 1, seen);
+  }
+
+  if (typeof obj === "function") {
+    var name = nameOf(obj);
+    var keys = arrObjKeys(obj, inspect);
+    return (
+      "[Function" +
+      (name ? ": " + name : " (anonymous)") +
+      "]" +
+      (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "")
+    );
+  }
+  if (isSymbol(obj)) {
+    var symString = hasShammedSymbols
+      ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1")
+      : symToString.call(obj);
+    return typeof obj === "object" && !hasShammedSymbols
+      ? markBoxed(symString)
+      : symString;
+  }
+  if (isElement(obj)) {
+    var s = "<" + $toLowerCase.call(String(obj.nodeName));
+    var attrs = obj.attributes || [];
+    for (var i = 0; i < attrs.length; i++) {
+      s +=
+        " " +
+        attrs[i].name +
+        "=" +
+        wrapQuotes(quote(attrs[i].value), "double", opts);
+    }
+    s += ">";
+    if (obj.childNodes && obj.childNodes.length) {
+      s += "...";
+    }
+    s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
+    return s;
+  }
+  if (isArray(obj)) {
+    if (obj.length === 0) {
+      return "[]";
+    }
+    var xs = arrObjKeys(obj, inspect);
+    if (indent && !singleLineValues(xs)) {
+      return "[" + indentedJoin(xs, indent) + "]";
+    }
+    return "[ " + $join.call(xs, ", ") + " ]";
+  }
+  if (isError(obj)) {
+    var parts = arrObjKeys(obj, inspect);
+    if ("cause" in obj && !isEnumerable.call(obj, "cause")) {
+      return (
+        "{ [" +
+        String(obj) +
+        "] " +
+        $join.call(
+          $concat.call("[cause]: " + inspect(obj.cause), parts),
+          ", "
+        ) +
+        " }"
+      );
+    }
+    if (parts.length === 0) {
+      return "[" + String(obj) + "]";
+    }
+    return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
+  }
+  if (typeof obj === "object" && customInspect) {
+    if (customInspect !== "symbol" && typeof obj.inspect === "function") {
+      return obj.inspect();
+    }
+  }
+  if (isMap(obj)) {
+    var mapParts = [];
+    mapForEach.call(obj, function (value, key) {
+      mapParts.push(inspect(key, obj, true) + " => " + inspect(value, obj));
+    });
+    return collectionOf("Map", mapSize.call(obj), mapParts, indent);
+  }
+  if (isSet(obj)) {
+    var setParts = [];
+    setForEach.call(obj, function (value) {
+      setParts.push(inspect(value, obj));
+    });
+    return collectionOf("Set", setSize.call(obj), setParts, indent);
+  }
+  if (isWeakMap(obj)) {
+    return weakCollectionOf("WeakMap");
+  }
+  if (isWeakSet(obj)) {
+    return weakCollectionOf("WeakSet");
+  }
+  if (isWeakRef(obj)) {
+    return weakCollectionOf("WeakRef");
+  }
+  if (isNumber(obj)) {
+    return markBoxed(inspect(Number(obj)));
+  }
+  if (isBigInt(obj)) {
+    return markBoxed(inspect(bigIntValueOf.call(obj)));
+  }
+  if (isBoolean(obj)) {
+    return markBoxed(booleanValueOf.call(obj));
+  }
+  if (isString(obj)) {
+    return markBoxed(inspect(String(obj)));
+  }
+  if (!isDate(obj) && !isRegExp(obj)) {
+    var ys = arrObjKeys(obj, inspect);
+    var isPlainObject = gPO
+      ? gPO(obj) === Object.prototype
+      : obj instanceof Object || obj.constructor === Object;
+    var protoTag = obj instanceof Object ? "" : "null prototype";
+    var stringTag =
+      !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj
+        ? $slice.call(toStr(obj), 8, -1)
+        : protoTag
+          ? "Object"
+          : "";
+    var constructorTag =
+      isPlainObject || typeof obj.constructor !== "function"
+        ? ""
+        : obj.constructor.name
+          ? obj.constructor.name + " "
+          : "";
+    var tag =
+      constructorTag +
+      (stringTag || protoTag
+        ? "[" +
+          $join.call($concat.call([], stringTag || [], protoTag || []), ": ") +
+          "] "
+        : "");
+    if (ys.length === 0) {
+      return tag + "{}";
+    }
+    if (indent) {
+      return tag + "{" + indentedJoin(ys, indent) + "}";
+    }
+    return tag + "{ " + $join.call(ys, ", ") + " }";
+  }
+  return String(obj);
+}
+
+function wrapQuotes(s, defaultStyle, opts) {
+  var quoteChar = (opts.quoteStyle || defaultStyle) === "double" ? '"' : "'";
+  return quoteChar + s + quoteChar;
+}
+
+function quote(s) {
+  return $replace.call(String(s), /"/g, "&quot;");
+}
+
+function isArray(obj) {
+  return (
+    toStr(obj) === "[object Array]" &&
+    (!toStringTag || !(typeof obj === "object" && toStringTag in obj))
+  );
+}
+function isDate(obj) {
+  return (
+    toStr(obj) === "[object Date]" &&
+    (!toStringTag || !(typeof obj === "object" && toStringTag in obj))
+  );
+}
+function isRegExp(obj) {
+  return (
+    toStr(obj) === "[object RegExp]" &&
+    (!toStringTag || !(typeof obj === "object" && toStringTag in obj))
+  );
+}
+function isError(obj) {
+  return (
+    toStr(obj) === "[object Error]" &&
+    (!toStringTag || !(typeof obj === "object" && toStringTag in obj))
+  );
+}
+function isString(obj) {
+  return (
+    toStr(obj) === "[object String]" &&
+    (!toStringTag || !(typeof obj === "object" && toStringTag in obj))
+  );
+}
+function isNumber(obj) {
+  return (
+    toStr(obj) === "[object Number]" &&
+    (!toStringTag || !(typeof obj === "object" && toStringTag in obj))
+  );
+}
+function isBoolean(obj) {
+  return (
+    toStr(obj) === "[object Boolean]" &&
+    (!toStringTag || !(typeof obj === "object" && toStringTag in obj))
+  );
+}
+
+// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives
+function isSymbol(obj) {
+  if (hasShammedSymbols) {
+    return obj && typeof obj === "object" && obj instanceof Symbol;
+  }
+  if (typeof obj === "symbol") {
+    return true;
+  }
+  if (!obj || typeof obj !== "object" || !symToString) {
+    return false;
+  }
+  try {
+    symToString.call(obj);
+    return true;
+  } catch (e) {}
+  return false;
+}
+
+function isBigInt(obj) {
+  if (!obj || typeof obj !== "object" || !bigIntValueOf) {
+    return false;
+  }
+  try {
+    bigIntValueOf.call(obj);
+    return true;
+  } catch (e) {}
+  return false;
+}
+
+var hasOwn =
+  Object.prototype.hasOwnProperty ||
+  function (key) {
+    return key in this;
+  };
+function has(obj, key) {
+  return hasOwn.call(obj, key);
+}
+
+function toStr(obj) {
+  return objectToString.call(obj);
+}
+
+function nameOf(f) {
+  if (f.name) {
+    return f.name;
+  }
+  var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
+  if (m) {
+    return m[1];
+  }
+  return null;
+}
+
+function indexOf(xs, x) {
+  if (xs.indexOf) {
+    return xs.indexOf(x);
+  }
+  for (var i = 0, l = xs.length; i < l; i++) {
+    if (xs[i] === x) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function isMap(x) {
+  if (!mapSize || !x || typeof x !== "object") {
+    return false;
+  }
+  try {
+    mapSize.call(x);
+    try {
+      setSize.call(x);
+    } catch (s) {
+      return true;
+    }
+    return x instanceof Map; // core-js workaround, pre-v2.5.0
+  } catch (e) {}
+  return false;
+}
+
+function isWeakMap(x) {
+  if (!weakMapHas || !x || typeof x !== "object") {
+    return false;
+  }
+  try {
+    weakMapHas.call(x, weakMapHas);
+    try {
+      weakSetHas.call(x, weakSetHas);
+    } catch (s) {
+      return true;
+    }
+    return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
+  } catch (e) {}
+  return false;
+}
+
+function isWeakRef(x) {
+  if (!weakRefDeref || !x || typeof x !== "object") {
+    return false;
+  }
+  try {
+    weakRefDeref.call(x);
+    return true;
+  } catch (e) {}
+  return false;
+}
+
+function isSet(x) {
+  if (!setSize || !x || typeof x !== "object") {
+    return false;
+  }
+  try {
+    setSize.call(x);
+    try {
+      mapSize.call(x);
+    } catch (m) {
+      return true;
+    }
+    return x instanceof Set; // core-js workaround, pre-v2.5.0
+  } catch (e) {}
+  return false;
+}
+
+function isWeakSet(x) {
+  if (!weakSetHas || !x || typeof x !== "object") {
+    return false;
+  }
+  try {
+    weakSetHas.call(x, weakSetHas);
+    try {
+      weakMapHas.call(x, weakMapHas);
+    } catch (s) {
+      return true;
+    }
+    return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
+  } catch (e) {}
+  return false;
+}
+
+function isElement(x) {
+  if (!x || typeof x !== "object") {
+    return false;
+  }
+  if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) {
+    return true;
+  }
+  return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
+}
+
+function inspectString(str, opts) {
+  if (str.length > opts.maxStringLength) {
+    var remaining = str.length - opts.maxStringLength;
+    var trailer =
+      "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
+    return (
+      inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer
+    );
+  }
+  // eslint-disable-next-line no-control-regex
+  var s = $replace.call(
+    $replace.call(str, /(['\\])/g, "\\$1"),
+    /[\x00-\x1f]/g,
+    lowbyte
+  );
+  return wrapQuotes(s, "single", opts);
+}
+
+function lowbyte(c) {
+  var n = c.charCodeAt(0);
+  var x = {
+    8: "b",
+    9: "t",
+    10: "n",
+    12: "f",
+    13: "r",
+  }[n];
+  if (x) {
+    return "\\" + x;
+  }
+  return "\\x" + (n < 0x10 ? "0" : "") + $toUpperCase.call(n.toString(16));
+}
+
+function markBoxed(str) {
+  return "Object(" + str + ")";
+}
+
+function weakCollectionOf(type) {
+  return type + " { ? }";
+}
+
+function collectionOf(type, size, entries, indent) {
+  var joinedEntries = indent
+    ? indentedJoin(entries, indent)
+    : $join.call(entries, ", ");
+  return type + " (" + size + ") {" + joinedEntries + "}";
+}
+
+function singleLineValues(xs) {
+  for (var i = 0; i < xs.length; i++) {
+    if (indexOf(xs[i], "\n") >= 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function getIndent(opts, depth) {
+  var baseIndent;
+  if (opts.indent === "\t") {
+    baseIndent = "\t";
+  } else if (typeof opts.indent === "number" && opts.indent > 0) {
+    baseIndent = $join.call(Array(opts.indent + 1), " ");
+  } else {
+    return null;
+  }
+  return {
+    base: baseIndent,
+    prev: $join.call(Array(depth + 1), baseIndent),
+  };
+}
+
+function indentedJoin(xs, indent) {
+  if (xs.length === 0) {
+    return "";
+  }
+  var lineJoiner = "\n" + indent.prev + indent.base;
+  return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
+}
+
+function arrObjKeys(obj, inspect) {
+  var isArr = isArray(obj);
+  var xs = [];
+  if (isArr) {
+    xs.length = obj.length;
+    for (var i = 0; i < obj.length; i++) {
+      xs[i] = has(obj, i) ? inspect(obj[i], obj) : "";
+    }
+  }
+  var syms = typeof gOPS === "function" ? gOPS(obj) : [];
+  var symMap;
+  if (hasShammedSymbols) {
+    symMap = {};
+    for (var k = 0; k < syms.length; k++) {
+      symMap["$" + syms[k]] = syms[k];
+    }
+  }
+
+  for (var key in obj) {
+    // eslint-disable-line no-restricted-syntax
+    if (!has(obj, key)) {
+      continue;
+    } // eslint-disable-line no-restricted-syntax, no-continue
+    if (isArr && String(Number(key)) === key && key < obj.length) {
+      continue;
+    } // eslint-disable-line no-restricted-syntax, no-continue
+    if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) {
+      // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section
+      continue; // eslint-disable-line no-restricted-syntax, no-continue
+    } else if ($test.call(/[^\w$]/, key)) {
+      xs.push(inspect(key, obj) + ": " + inspect(obj[key], obj));
+    } else {
+      xs.push(key + ": " + inspect(obj[key], obj));
+    }
+  }
+  if (typeof gOPS === "function") {
+    for (var j = 0; j < syms.length; j++) {
+      if (isEnumerable.call(obj, syms[j])) {
+        xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj));
+      }
+    }
+  }
+  return xs;
+}

package/preview/__previewjs_internal__/renderer/index.tsx

@@ -0,0 +1,12 @@
+import type { RendererLoader } from "../../../src";
+
+/**
+ * 该函数目前是一个占位函数，在运行时会被特定框架的实现所替换。
+ *
+ * @returns 此函数理论上应返回渲染器，但当前实现会抛出错误。
+ * @throws {Error} 当该占位函数被调用时，会抛出“Dummy loader was invoked!”错误。
+ */
+export const loadRenderer: RendererLoader = () => {
+  // 这是一个占位函数，在运行时会被特定框架的实现所替换。
+  throw new Error("调用到占位 loader 函数");
+};