@vc-shell/framework 1.2.0 → 1.2.2

package/dist/vendor-dom-serializer-Sk3xHhQk.js

@@ -0,0 +1,213 @@
+import { T as d, a as u, S as m, b as g, C as h, c as p, D as x, d as M, R as C } from "./vendor-domelementtype-B3sFIGaC.js";
+import { e as l, a as b, b as T } from "./vendor-entities-CCReaWqU.js";
+const v = new Map([
+  "altGlyph",
+  "altGlyphDef",
+  "altGlyphItem",
+  "animateColor",
+  "animateMotion",
+  "animateTransform",
+  "clipPath",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "foreignObject",
+  "glyphRef",
+  "linearGradient",
+  "radialGradient",
+  "textPath"
+].map((e) => [e.toLowerCase(), e])), A = new Map([
+  "definitionURL",
+  "attributeName",
+  "attributeType",
+  "baseFrequency",
+  "baseProfile",
+  "calcMode",
+  "clipPathUnits",
+  "diffuseConstant",
+  "edgeMode",
+  "filterUnits",
+  "glyphRef",
+  "gradientTransform",
+  "gradientUnits",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keyPoints",
+  "keySplines",
+  "keyTimes",
+  "lengthAdjust",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerUnits",
+  "markerWidth",
+  "maskContentUnits",
+  "maskUnits",
+  "numOctaves",
+  "pathLength",
+  "patternContentUnits",
+  "patternTransform",
+  "patternUnits",
+  "pointsAtX",
+  "pointsAtY",
+  "pointsAtZ",
+  "preserveAlpha",
+  "preserveAspectRatio",
+  "primitiveUnits",
+  "refX",
+  "refY",
+  "repeatCount",
+  "repeatDur",
+  "requiredExtensions",
+  "requiredFeatures",
+  "specularConstant",
+  "specularExponent",
+  "spreadMethod",
+  "startOffset",
+  "stdDeviation",
+  "stitchTiles",
+  "surfaceScale",
+  "systemLanguage",
+  "tableValues",
+  "targetX",
+  "targetY",
+  "textLength",
+  "viewBox",
+  "viewTarget",
+  "xChannelSelector",
+  "yChannelSelector",
+  "zoomAndPan"
+].map((e) => [e.toLowerCase(), e])), y = /* @__PURE__ */ new Set([
+  "style",
+  "script",
+  "xmp",
+  "iframe",
+  "noembed",
+  "noframes",
+  "plaintext",
+  "noscript"
+]);
+function S(e) {
+  return e.replace(/"/g, """);
+}
+function w(e, t) {
+  var a;
+  if (!e)
+    return;
+  const n = ((a = t.encodeEntities) !== null && a !== void 0 ? a : t.decodeEntities) === !1 ? S : t.xmlMode || t.encodeEntities !== "utf8" ? l : T;
+  return Object.keys(e).map((r) => {
+    var i, s;
+    const o = (i = e[r]) !== null && i !== void 0 ? i : "";
+    return t.xmlMode === "foreign" && (r = (s = A.get(r)) !== null && s !== void 0 ? s : r), !t.emptyAttrs && !t.xmlMode && o === "" ? r : `${r}="${n(o)}"`;
+  }).join(" ");
+}
+const f = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "basefont",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "frame",
+  "hr",
+  "img",
+  "input",
+  "isindex",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function c(e, t = {}) {
+  const a = "length" in e ? e : [e];
+  let n = "";
+  for (let r = 0; r < a.length; r++)
+    n += D(a[r], t);
+  return n;
+}
+function D(e, t) {
+  switch (e.type) {
+    case C:
+      return c(e.children, t);
+    // @ts-expect-error We don't use `Doctype` yet
+    case M:
+    case x:
+      return k(e);
+    case p:
+      return F(e);
+    case h:
+      return $(e);
+    case g:
+    case m:
+    case u:
+      return E(e, t);
+    case d:
+      return P(e, t);
+  }
+}
+const L = /* @__PURE__ */ new Set([
+  "mi",
+  "mo",
+  "mn",
+  "ms",
+  "mtext",
+  "annotation-xml",
+  "foreignObject",
+  "desc",
+  "title"
+]), U = /* @__PURE__ */ new Set(["svg", "math"]);
+function E(e, t) {
+  var a;
+  t.xmlMode === "foreign" && (e.name = (a = v.get(e.name)) !== null && a !== void 0 ? a : e.name, e.parent && L.has(e.parent.name) && (t = { ...t, xmlMode: !1 })), !t.xmlMode && U.has(e.name) && (t = { ...t, xmlMode: "foreign" });
+  let n = `<${e.name}`;
+  const r = w(e.attribs, t);
+  return r && (n += ` ${r}`), e.children.length === 0 && (t.xmlMode ? (
+    // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags
+    t.selfClosingTags !== !1
+  ) : (
+    // User explicitly asked for self-closing tags, even in HTML mode
+    t.selfClosingTags && f.has(e.name)
+  )) ? (t.xmlMode || (n += " "), n += "/>") : (n += ">", e.children.length > 0 && (n += c(e.children, t)), (t.xmlMode || !f.has(e.name)) && (n += `</${e.name}>`)), n;
+}
+function k(e) {
+  return `<${e.data}>`;
+}
+function P(e, t) {
+  var a;
+  let n = e.data || "";
+  return ((a = t.encodeEntities) !== null && a !== void 0 ? a : t.decodeEntities) !== !1 && !(!t.xmlMode && e.parent && y.has(e.parent.name)) && (n = t.xmlMode || t.encodeEntities !== "utf8" ? l(n) : b(n)), n;
+}
+function $(e) {
+  return `<![CDATA[${e.children[0].data}]]>`;
+}
+function F(e) {
+  return `<!--${e.data}-->`;
+}
+export {
+  c as r
+};

package/dist/vendor-domelementtype-B3sFIGaC.js

@@ -0,0 +1,21 @@
+var t;
+(function(o) {
+  o.Root = "root", o.Text = "text", o.Directive = "directive", o.Comment = "comment", o.Script = "script", o.Style = "style", o.Tag = "tag", o.CDATA = "cdata", o.Doctype = "doctype";
+})(t || (t = {}));
+function c(o) {
+  return o.type === t.Tag || o.type === t.Script || o.type === t.Style;
+}
+const s = t.Root, a = t.Text, i = t.Directive, r = t.Comment, n = t.Script, D = t.Style, S = t.Tag, C = t.CDATA, g = t.Doctype;
+export {
+  C,
+  i as D,
+  t as E,
+  s as R,
+  D as S,
+  a as T,
+  S as a,
+  n as b,
+  r as c,
+  g as d,
+  c as i
+};

package/dist/vendor-domhandler-CL40eeX9.js

@@ -0,0 +1,311 @@
+import { E as r, i as y } from "./vendor-domelementtype-B3sFIGaC.js";
+class p {
+  constructor() {
+    this.parent = null, this.prev = null, this.next = null, this.startIndex = null, this.endIndex = null;
+  }
+  // Read-write aliases for properties
+  /**
+   * Same as {@link parent}.
+   * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+   */
+  get parentNode() {
+    return this.parent;
+  }
+  set parentNode(t) {
+    this.parent = t;
+  }
+  /**
+   * Same as {@link prev}.
+   * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+   */
+  get previousSibling() {
+    return this.prev;
+  }
+  set previousSibling(t) {
+    this.prev = t;
+  }
+  /**
+   * Same as {@link next}.
+   * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+   */
+  get nextSibling() {
+    return this.next;
+  }
+  set nextSibling(t) {
+    this.next = t;
+  }
+  /**
+   * Clone this node, and optionally its children.
+   *
+   * @param recursive Clone child nodes as well.
+   * @returns A clone of the node.
+   */
+  cloneNode(t = !1) {
+    return N(this, t);
+  }
+}
+class c extends p {
+  /**
+   * @param data The content of the data node
+   */
+  constructor(t) {
+    super(), this.data = t;
+  }
+  /**
+   * Same as {@link data}.
+   * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+   */
+  get nodeValue() {
+    return this.data;
+  }
+  set nodeValue(t) {
+    this.data = t;
+  }
+}
+class o extends c {
+  constructor() {
+    super(...arguments), this.type = r.Text;
+  }
+  get nodeType() {
+    return 3;
+  }
+}
+class f extends c {
+  constructor() {
+    super(...arguments), this.type = r.Comment;
+  }
+  get nodeType() {
+    return 8;
+  }
+}
+class x extends c {
+  constructor(t, s) {
+    super(s), this.name = t, this.type = r.Directive;
+  }
+  get nodeType() {
+    return 1;
+  }
+}
+class d extends p {
+  /**
+   * @param children Children of the node. Only certain node types can have children.
+   */
+  constructor(t) {
+    super(), this.children = t;
+  }
+  // Aliases
+  /** First child of the node. */
+  get firstChild() {
+    var t;
+    return (t = this.children[0]) !== null && t !== void 0 ? t : null;
+  }
+  /** Last child of the node. */
+  get lastChild() {
+    return this.children.length > 0 ? this.children[this.children.length - 1] : null;
+  }
+  /**
+   * Same as {@link children}.
+   * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+   */
+  get childNodes() {
+    return this.children;
+  }
+  set childNodes(t) {
+    this.children = t;
+  }
+}
+class m extends d {
+  constructor() {
+    super(...arguments), this.type = r.CDATA;
+  }
+  get nodeType() {
+    return 4;
+  }
+}
+class h extends d {
+  constructor() {
+    super(...arguments), this.type = r.Root;
+  }
+  get nodeType() {
+    return 9;
+  }
+}
+class g extends d {
+  /**
+   * @param name Name of the tag, eg. `div`, `span`.
+   * @param attribs Object mapping attribute names to attribute values.
+   * @param children Children of the node.
+   */
+  constructor(t, s, n = [], i = t === "script" ? r.Script : t === "style" ? r.Style : r.Tag) {
+    super(n), this.name = t, this.attribs = s, this.type = i;
+  }
+  get nodeType() {
+    return 1;
+  }
+  // DOM Level 1 aliases
+  /**
+   * Same as {@link name}.
+   * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+   */
+  get tagName() {
+    return this.name;
+  }
+  set tagName(t) {
+    this.name = t;
+  }
+  get attributes() {
+    return Object.keys(this.attribs).map((t) => {
+      var s, n;
+      return {
+        name: t,
+        value: this.attribs[t],
+        namespace: (s = this["x-attribsNamespace"]) === null || s === void 0 ? void 0 : s[t],
+        prefix: (n = this["x-attribsPrefix"]) === null || n === void 0 ? void 0 : n[t]
+      };
+    });
+  }
+}
+function b(e) {
+  return y(e);
+}
+function I(e) {
+  return e.type === r.CDATA;
+}
+function w(e) {
+  return e.type === r.Text;
+}
+function C(e) {
+  return e.type === r.Comment;
+}
+function T(e) {
+  return e.type === r.Directive;
+}
+function v(e) {
+  return e.type === r.Root;
+}
+function D(e) {
+  return Object.prototype.hasOwnProperty.call(e, "children");
+}
+function N(e, t = !1) {
+  let s;
+  if (w(e))
+    s = new o(e.data);
+  else if (C(e))
+    s = new f(e.data);
+  else if (b(e)) {
+    const n = t ? l(e.children) : [], i = new g(e.name, { ...e.attribs }, n);
+    n.forEach((a) => a.parent = i), e.namespace != null && (i.namespace = e.namespace), e["x-attribsNamespace"] && (i["x-attribsNamespace"] = { ...e["x-attribsNamespace"] }), e["x-attribsPrefix"] && (i["x-attribsPrefix"] = { ...e["x-attribsPrefix"] }), s = i;
+  } else if (I(e)) {
+    const n = t ? l(e.children) : [], i = new m(n);
+    n.forEach((a) => a.parent = i), s = i;
+  } else if (v(e)) {
+    const n = t ? l(e.children) : [], i = new h(n);
+    n.forEach((a) => a.parent = i), e["x-mode"] && (i["x-mode"] = e["x-mode"]), s = i;
+  } else if (T(e)) {
+    const n = new x(e.name, e.data);
+    e["x-name"] != null && (n["x-name"] = e["x-name"], n["x-publicId"] = e["x-publicId"], n["x-systemId"] = e["x-systemId"]), s = n;
+  } else
+    throw new Error(`Not implemented yet: ${e.type}`);
+  return s.startIndex = e.startIndex, s.endIndex = e.endIndex, e.sourceCodeLocation != null && (s.sourceCodeLocation = e.sourceCodeLocation), s;
+}
+function l(e) {
+  const t = e.map((s) => N(s, !0));
+  for (let s = 1; s < t.length; s++)
+    t[s].prev = t[s - 1], t[s - 1].next = t[s];
+  return t;
+}
+const u = {
+  withStartIndices: !1,
+  withEndIndices: !1,
+  xmlMode: !1
+};
+class E {
+  /**
+   * @param callback Called once parsing has completed.
+   * @param options Settings for the handler.
+   * @param elementCB Callback whenever a tag is closed.
+   */
+  constructor(t, s, n) {
+    this.dom = [], this.root = new h(this.dom), this.done = !1, this.tagStack = [this.root], this.lastNode = null, this.parser = null, typeof s == "function" && (n = s, s = u), typeof t == "object" && (s = t, t = void 0), this.callback = t ?? null, this.options = s ?? u, this.elementCB = n ?? null;
+  }
+  onparserinit(t) {
+    this.parser = t;
+  }
+  // Resets the handler back to starting state
+  onreset() {
+    this.dom = [], this.root = new h(this.dom), this.done = !1, this.tagStack = [this.root], this.lastNode = null, this.parser = null;
+  }
+  // Signals the handler that parsing is done
+  onend() {
+    this.done || (this.done = !0, this.parser = null, this.handleCallback(null));
+  }
+  onerror(t) {
+    this.handleCallback(t);
+  }
+  onclosetag() {
+    this.lastNode = null;
+    const t = this.tagStack.pop();
+    this.options.withEndIndices && (t.endIndex = this.parser.endIndex), this.elementCB && this.elementCB(t);
+  }
+  onopentag(t, s) {
+    const n = this.options.xmlMode ? r.Tag : void 0, i = new g(t, s, void 0, n);
+    this.addNode(i), this.tagStack.push(i);
+  }
+  ontext(t) {
+    const { lastNode: s } = this;
+    if (s && s.type === r.Text)
+      s.data += t, this.options.withEndIndices && (s.endIndex = this.parser.endIndex);
+    else {
+      const n = new o(t);
+      this.addNode(n), this.lastNode = n;
+    }
+  }
+  oncomment(t) {
+    if (this.lastNode && this.lastNode.type === r.Comment) {
+      this.lastNode.data += t;
+      return;
+    }
+    const s = new f(t);
+    this.addNode(s), this.lastNode = s;
+  }
+  oncommentend() {
+    this.lastNode = null;
+  }
+  oncdatastart() {
+    const t = new o(""), s = new m([t]);
+    this.addNode(s), t.parent = s, this.lastNode = t;
+  }
+  oncdataend() {
+    this.lastNode = null;
+  }
+  onprocessinginstruction(t, s) {
+    const n = new x(t, s);
+    this.addNode(n);
+  }
+  handleCallback(t) {
+    if (typeof this.callback == "function")
+      this.callback(t, this.dom);
+    else if (t)
+      throw t;
+  }
+  addNode(t) {
+    const s = this.tagStack[this.tagStack.length - 1], n = s.children[s.children.length - 1];
+    this.options.withStartIndices && (t.startIndex = this.parser.startIndex), this.options.withEndIndices && (t.endIndex = this.parser.endIndex), s.children.push(t), n && (t.prev = n, n.next = t), t.parent = s, this.lastNode = null;
+  }
+}
+export {
+  f as C,
+  h as D,
+  g as E,
+  x as P,
+  o as T,
+  v as a,
+  C as b,
+  N as c,
+  w as d,
+  I as e,
+  E as f,
+  T as g,
+  D as h,
+  b as i
+};