@easyv/biz-components 0.0.20 → 0.0.22

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.es.js

@@ -1,224 +1,321 @@
-import { markdownLineEnding as V } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
-import { push as W, splice as X } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
-import { resolveAll as Y } from "../../../../micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.es.js";
-function re(d, l, o) {
-  let n = {
+import { markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+import { push, splice } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+import { resolveAll } from "../../../../micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.es.js";
+function createTokenizer(parser, initialize, from) {
+  let point = {
     _bufferIndex: -1,
     _index: 0,
-    line: o && o.line || 1,
-    column: o && o.column || 1,
-    offset: o && o.offset || 0
+    line: from && from.line || 1,
+    column: from && from.column || 1,
+    offset: from && from.offset || 0
   };
-  const f = {}, u = [];
-  let s = [], h = [];
-  const S = {
-    attempt: m(J),
-    check: m(P),
-    consume: D,
-    enter: G,
-    exit: H,
-    interrupt: m(P, {
-      interrupt: !0
+  const columnStart = {};
+  const resolveAllConstructs = [];
+  let chunks = [];
+  let stack = [];
+  const effects = {
+    attempt: constructFactory(onsuccessfulconstruct),
+    check: constructFactory(onsuccessfulcheck),
+    consume,
+    enter,
+    exit,
+    interrupt: constructFactory(onsuccessfulcheck, {
+      interrupt: true
     })
-  }, t = {
+  };
+  const context = {
     code: null,
     containerState: {},
-    defineSkip: R,
+    defineSkip,
     events: [],
-    now: v,
-    parser: d,
+    now,
+    parser,
     previous: null,
-    sliceSerialize: M,
-    sliceStream: j,
-    write: L
+    sliceSerialize,
+    sliceStream,
+    write
   };
-  let O = l.tokenize.call(t, S);
-  return l.resolveAll && u.push(l), t;
-  function L(e) {
-    return s = W(s, e), q(), s[s.length - 1] !== null ? [] : (T(l, 0), t.events = Y(u, t.events, t), t.events);
+  let state = initialize.tokenize.call(context, effects);
+  if (initialize.resolveAll) {
+    resolveAllConstructs.push(initialize);
+  }
+  return context;
+  function write(slice) {
+    chunks = push(chunks, slice);
+    main();
+    if (chunks[chunks.length - 1] !== null) {
+      return [];
+    }
+    addResult(initialize, 0);
+    context.events = resolveAll(resolveAllConstructs, context.events, context);
+    return context.events;
   }
-  function M(e, r) {
-    return $(j(e), r);
+  function sliceSerialize(token, expandTabs) {
+    return serializeChunks(sliceStream(token), expandTabs);
   }
-  function j(e) {
-    return Z(s, e);
+  function sliceStream(token) {
+    return sliceChunks(chunks, token);
   }
-  function v() {
+  function now() {
     const {
-      _bufferIndex: e,
-      _index: r,
-      line: c,
-      column: a,
-      offset: p
-    } = n;
+      _bufferIndex,
+      _index,
+      line,
+      column,
+      offset
+    } = point;
     return {
-      _bufferIndex: e,
-      _index: r,
-      line: c,
-      column: a,
-      offset: p
+      _bufferIndex,
+      _index,
+      line,
+      column,
+      offset
     };
   }
-  function R(e) {
-    f[e.line] = e.column, g();
-  }
-  function q() {
-    let e;
-    for (; n._index < s.length; ) {
-      const r = s[n._index];
-      if (typeof r == "string")
-        for (e = n._index, n._bufferIndex < 0 && (n._bufferIndex = 0); n._index === e && n._bufferIndex < r.length; )
-          z(r.charCodeAt(n._bufferIndex));
-      else
-        z(r);
+  function defineSkip(value) {
+    columnStart[value.line] = value.column;
+    accountForPotentialSkip();
+  }
+  function main() {
+    let chunkIndex;
+    while (point._index < chunks.length) {
+      const chunk = chunks[point._index];
+      if (typeof chunk === "string") {
+        chunkIndex = point._index;
+        if (point._bufferIndex < 0) {
+          point._bufferIndex = 0;
+        }
+        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {
+          go(chunk.charCodeAt(point._bufferIndex));
+        }
+      } else {
+        go(chunk);
+      }
     }
   }
-  function z(e) {
-    O = O(e);
+  function go(code) {
+    state = state(code);
   }
-  function D(e) {
-    V(e) ? (n.line++, n.column = 1, n.offset += e === -3 ? 2 : 1, g()) : e !== -1 && (n.column++, n.offset++), n._bufferIndex < 0 ? n._index++ : (n._bufferIndex++, n._bufferIndex === // Points w/ non-negative `_bufferIndex` reference
-    // strings.
-    /** @type {string} */
-    s[n._index].length && (n._bufferIndex = -1, n._index++)), t.previous = e;
+  function consume(code) {
+    if (markdownLineEnding(code)) {
+      point.line++;
+      point.column = 1;
+      point.offset += code === -3 ? 2 : 1;
+      accountForPotentialSkip();
+    } else if (code !== -1) {
+      point.column++;
+      point.offset++;
+    }
+    if (point._bufferIndex < 0) {
+      point._index++;
+    } else {
+      point._bufferIndex++;
+      if (point._bufferIndex === // Points w/ non-negative `_bufferIndex` reference
+      // strings.
+      /** @type {string} */
+      chunks[point._index].length) {
+        point._bufferIndex = -1;
+        point._index++;
+      }
+    }
+    context.previous = code;
   }
-  function G(e, r) {
-    const c = r || {};
-    return c.type = e, c.start = v(), t.events.push(["enter", c, t]), h.push(c), c;
+  function enter(type, fields) {
+    const token = fields || {};
+    token.type = type;
+    token.start = now();
+    context.events.push(["enter", token, context]);
+    stack.push(token);
+    return token;
   }
-  function H(e) {
-    const r = h.pop();
-    return r.end = v(), t.events.push(["exit", r, t]), r;
+  function exit(type) {
+    const token = stack.pop();
+    token.end = now();
+    context.events.push(["exit", token, context]);
+    return token;
   }
-  function J(e, r) {
-    T(e, r.from);
+  function onsuccessfulconstruct(construct, info) {
+    addResult(construct, info.from);
   }
-  function P(e, r) {
-    r.restore();
+  function onsuccessfulcheck(_, info) {
+    info.restore();
   }
-  function m(e, r) {
-    return c;
-    function c(a, p, _) {
-      let C, k, B, y;
-      return Array.isArray(a) ? (
+  function constructFactory(onreturn, fields) {
+    return hook;
+    function hook(constructs, returnState, bogusState) {
+      let listOfConstructs;
+      let constructIndex;
+      let currentConstruct;
+      let info;
+      return Array.isArray(constructs) ? (
         /* c8 ignore next 1 */
-        A(a)
-      ) : "tokenize" in a ? (
+        handleListOfConstructs(constructs)
+      ) : "tokenize" in constructs ? (
         // Looks like a construct.
-        A([
+        handleListOfConstructs([
           /** @type {Construct} */
-          a
+          constructs
         ])
-      ) : N(a);
-      function N(i) {
-        return w;
-        function w(x) {
-          const b = x !== null && i[x], I = x !== null && i.null, U = [
+      ) : handleMapOfConstructs(constructs);
+      function handleMapOfConstructs(map) {
+        return start;
+        function start(code) {
+          const left = code !== null && map[code];
+          const all = code !== null && map.null;
+          const list = [
             // To do: add more extension tests.
             /* c8 ignore next 2 */
-            ...Array.isArray(b) ? b : b ? [b] : [],
-            ...Array.isArray(I) ? I : I ? [I] : []
+            ...Array.isArray(left) ? left : left ? [left] : [],
+            ...Array.isArray(all) ? all : all ? [all] : []
           ];
-          return A(U)(x);
+          return handleListOfConstructs(list)(code);
         }
       }
-      function A(i) {
-        return C = i, k = 0, i.length === 0 ? _ : E(i[k]);
+      function handleListOfConstructs(list) {
+        listOfConstructs = list;
+        constructIndex = 0;
+        if (list.length === 0) {
+          return bogusState;
+        }
+        return handleConstruct(list[constructIndex]);
       }
-      function E(i) {
-        return w;
-        function w(x) {
-          return y = K(), B = i, i.partial || (t.currentConstruct = i), i.name && t.parser.constructs.disable.null.includes(i.name) ? F() : i.tokenize.call(
+      function handleConstruct(construct) {
+        return start;
+        function start(code) {
+          info = store();
+          currentConstruct = construct;
+          if (!construct.partial) {
+            context.currentConstruct = construct;
+          }
+          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {
+            return nok();
+          }
+          return construct.tokenize.call(
             // If we do have fields, create an object w/ `context` as its
             // prototype.
             // This allows a “live binding”, which is needed for `interrupt`.
-            r ? Object.assign(Object.create(t), r) : t,
-            S,
-            Q,
-            F
-          )(x);
+            fields ? Object.assign(Object.create(context), fields) : context,
+            effects,
+            ok,
+            nok
+          )(code);
         }
       }
-      function Q(i) {
-        return e(B, y), p;
+      function ok(code) {
+        onreturn(currentConstruct, info);
+        return returnState;
       }
-      function F(i) {
-        return y.restore(), ++k < C.length ? E(C[k]) : _;
+      function nok(code) {
+        info.restore();
+        if (++constructIndex < listOfConstructs.length) {
+          return handleConstruct(listOfConstructs[constructIndex]);
+        }
+        return bogusState;
       }
     }
   }
-  function T(e, r) {
-    e.resolveAll && !u.includes(e) && u.push(e), e.resolve && X(t.events, r, t.events.length - r, e.resolve(t.events.slice(r), t)), e.resolveTo && (t.events = e.resolveTo(t.events, t));
+  function addResult(construct, from2) {
+    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
+      resolveAllConstructs.push(construct);
+    }
+    if (construct.resolve) {
+      splice(context.events, from2, context.events.length - from2, construct.resolve(context.events.slice(from2), context));
+    }
+    if (construct.resolveTo) {
+      context.events = construct.resolveTo(context.events, context);
+    }
   }
-  function K() {
-    const e = v(), r = t.previous, c = t.currentConstruct, a = t.events.length, p = Array.from(h);
+  function store() {
+    const startPoint = now();
+    const startPrevious = context.previous;
+    const startCurrentConstruct = context.currentConstruct;
+    const startEventsIndex = context.events.length;
+    const startStack = Array.from(stack);
     return {
-      from: a,
-      restore: _
+      from: startEventsIndex,
+      restore
     };
-    function _() {
-      n = e, t.previous = r, t.currentConstruct = c, t.events.length = a, h = p, g();
+    function restore() {
+      point = startPoint;
+      context.previous = startPrevious;
+      context.currentConstruct = startCurrentConstruct;
+      context.events.length = startEventsIndex;
+      stack = startStack;
+      accountForPotentialSkip();
     }
   }
-  function g() {
-    n.line in f && n.column < 2 && (n.column = f[n.line], n.offset += f[n.line] - 1);
+  function accountForPotentialSkip() {
+    if (point.line in columnStart && point.column < 2) {
+      point.column = columnStart[point.line];
+      point.offset += columnStart[point.line] - 1;
+    }
   }
 }
-function Z(d, l) {
-  const o = l.start._index, n = l.start._bufferIndex, f = l.end._index, u = l.end._bufferIndex;
-  let s;
-  if (o === f)
-    s = [d[o].slice(n, u)];
-  else {
-    if (s = d.slice(o, f), n > -1) {
-      const h = s[0];
-      typeof h == "string" ? s[0] = h.slice(n) : s.shift();
+function sliceChunks(chunks, token) {
+  const startIndex = token.start._index;
+  const startBufferIndex = token.start._bufferIndex;
+  const endIndex = token.end._index;
+  const endBufferIndex = token.end._bufferIndex;
+  let view;
+  if (startIndex === endIndex) {
+    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
+  } else {
+    view = chunks.slice(startIndex, endIndex);
+    if (startBufferIndex > -1) {
+      const head = view[0];
+      if (typeof head === "string") {
+        view[0] = head.slice(startBufferIndex);
+      } else {
+        view.shift();
+      }
+    }
+    if (endBufferIndex > 0) {
+      view.push(chunks[endIndex].slice(0, endBufferIndex));
     }
-    u > 0 && s.push(d[f].slice(0, u));
   }
-  return s;
+  return view;
 }
-function $(d, l) {
-  let o = -1;
-  const n = [];
-  let f;
-  for (; ++o < d.length; ) {
-    const u = d[o];
-    let s;
-    if (typeof u == "string")
-      s = u;
-    else switch (u) {
+function serializeChunks(chunks, expandTabs) {
+  let index = -1;
+  const result = [];
+  let atTab;
+  while (++index < chunks.length) {
+    const chunk = chunks[index];
+    let value;
+    if (typeof chunk === "string") {
+      value = chunk;
+    } else switch (chunk) {
       case -5: {
-        s = "\r";
+        value = "\r";
         break;
       }
       case -4: {
-        s = `
-`;
+        value = "\n";
         break;
       }
       case -3: {
-        s = `\r
-`;
+        value = "\r\n";
         break;
       }
       case -2: {
-        s = l ? " " : "	";
+        value = expandTabs ? " " : "	";
         break;
       }
       case -1: {
-        if (!l && f) continue;
-        s = " ";
+        if (!expandTabs && atTab) continue;
+        value = " ";
         break;
       }
-      default:
-        s = String.fromCharCode(u);
+      default: {
+        value = String.fromCharCode(chunk);
+      }
     }
-    f = u === -2, n.push(s);
+    atTab = chunk === -2;
+    result.push(value);
   }
-  return n.join("");
+  return result.join("");
 }
 export {
-  re as createTokenizer
+  createTokenizer
 };
 //# sourceMappingURL=create-tokenizer.es.js.map

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-tokenizer.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.js"],"sourcesContent":["/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n        /* c8 ignore next 4 -- used to be used, no longer */\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}"],"names":["createTokenizer","parser","initialize","from","point","columnStart","resolveAllConstructs","chunks","stack","effects","constructFactory","onsuccessfulconstruct","onsuccessfulcheck","consume","enter","exit","context","defineSkip","now","sliceSerialize","sliceStream","write","state","slice","push","main","addResult","resolveAll","token","expandTabs","serializeChunks","sliceChunks","_bufferIndex","_index","line","column","offset","value","accountForPotentialSkip","chunkIndex","chunk","go","code","markdownLineEnding","type","fields","construct","info","_","onreturn","hook","constructs","returnState","bogusState","listOfConstructs","constructIndex","currentConstruct","handleListOfConstructs","handleMapOfConstructs","map","start","left","all","list","handleConstruct","store","nok","ok","splice","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","restore","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","index","result","atTab"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"create-tokenizer.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.js"],"sourcesContent":["/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n        /* c8 ignore next 4 -- used to be used, no longer */\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}"],"names":["from"],"mappings":";;;AA4DO,SAAS,gBAAgB,QAAQ,YAAY,MAAM;AAExD,MAAI,QAAQ;AAAA,IACV,cAAc;AAAA,IACd,QAAQ;AAAA,IACR,MAAM,QAAQ,KAAK,QAAQ;AAAA,IAC3B,QAAQ,QAAQ,KAAK,UAAU;AAAA,IAC/B,QAAQ,QAAQ,KAAK,UAAU;AAAA,EAChC;AAED,QAAM,cAAc,CAAE;AAEtB,QAAM,uBAAuB,CAAE;AAE/B,MAAI,SAAS,CAAE;AAEf,MAAI,QAAQ,CAAE;AASd,QAAM,UAAU;AAAA,IACd,SAAS,iBAAiB,qBAAqB;AAAA,IAC/C,OAAO,iBAAiB,iBAAiB;AAAA,IACzC;AAAA,IACA;AAAA,IACA;AAAA,IACA,WAAW,iBAAiB,mBAAmB;AAAA,MAC7C,WAAW;AAAA,IACZ,CAAA;AAAA,EACF;AAOD,QAAM,UAAU;AAAA,IACd,MAAM;AAAA,IACN,gBAAgB,CAAE;AAAA,IAClB;AAAA,IACA,QAAQ,CAAE;AAAA,IACV;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,EACD;AAOD,MAAI,QAAQ,WAAW,SAAS,KAAK,SAAS,OAAO;AAQrD,MAAI,WAAW,YAAY;AACzB,yBAAqB,KAAK,UAAU;AAAA,EACxC;AACE,SAAO;AAGP,WAAS,MAAM,OAAO;AACpB,aAAS,KAAK,QAAQ,KAAK;AAC3B,SAAM;AAGN,QAAI,OAAO,OAAO,SAAS,CAAC,MAAM,MAAM;AACtC,aAAO,CAAE;AAAA,IACf;AACI,cAAU,YAAY,CAAC;AAGvB,YAAQ,SAAS,WAAW,sBAAsB,QAAQ,QAAQ,OAAO;AACzE,WAAO,QAAQ;AAAA,EACnB;AAOE,WAAS,eAAe,OAAO,YAAY;AACzC,WAAO,gBAAgB,YAAY,KAAK,GAAG,UAAU;AAAA,EACzD;AAGE,WAAS,YAAY,OAAO;AAC1B,WAAO,YAAY,QAAQ,KAAK;AAAA,EACpC;AAGE,WAAS,MAAM;AAEb,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN,IAAQ;AACJ,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACD;AAAA,EACL;AAGE,WAAS,WAAW,OAAO;AACzB,gBAAY,MAAM,IAAI,IAAI,MAAM;AAChC,4BAAyB;AAAA,EAC7B;AAiBE,WAAS,OAAO;AAEd,QAAI;AACJ,WAAO,MAAM,SAAS,OAAO,QAAQ;AACnC,YAAM,QAAQ,OAAO,MAAM,MAAM;AAGjC,UAAI,OAAO,UAAU,UAAU;AAC7B,qBAAa,MAAM;AACnB,YAAI,MAAM,eAAe,GAAG;AAC1B,gBAAM,eAAe;AAAA,QAC/B;AACQ,eAAO,MAAM,WAAW,cAAc,MAAM,eAAe,MAAM,QAAQ;AACvE,aAAG,MAAM,WAAW,MAAM,YAAY,CAAC;AAAA,QACjD;AAAA,MACA,OAAa;AACL,WAAG,KAAK;AAAA,MAChB;AAAA,IACA;AAAA,EACA;AAUE,WAAS,GAAG,MAAM;AAGhB,YAAQ,MAAM,IAAI;AAAA,EACtB;AAGE,WAAS,QAAQ,MAAM;AACrB,QAAI,mBAAmB,IAAI,GAAG;AAC5B,YAAM;AACN,YAAM,SAAS;AACf,YAAM,UAAU,SAAS,KAAK,IAAI;AAClC,8BAAyB;AAAA,IAC/B,WAAe,SAAS,IAAI;AACtB,YAAM;AACN,YAAM;AAAA,IACZ;AAGI,QAAI,MAAM,eAAe,GAAG;AAC1B,YAAM;AAAA,IACZ,OAAW;AACL,YAAM;AAGN,UAAI,MAAM;AAAA;AAAA;AAAA,MAIV,OAAO,MAAM,MAAM,EAAE,QAAQ;AAC3B,cAAM,eAAe;AACrB,cAAM;AAAA,MACd;AAAA,IACA;AAGI,YAAQ,WAAW;AAAA,EAIvB;AAGE,WAAS,MAAM,MAAM,QAAQ;AAG3B,UAAM,QAAQ,UAAU,CAAE;AAC1B,UAAM,OAAO;AACb,UAAM,QAAQ,IAAK;AACnB,YAAQ,OAAO,KAAK,CAAC,SAAS,OAAO,OAAO,CAAC;AAC7C,UAAM,KAAK,KAAK;AAChB,WAAO;AAAA,EACX;AAGE,WAAS,KAAK,MAAM;AAClB,UAAM,QAAQ,MAAM,IAAK;AACzB,UAAM,MAAM,IAAK;AACjB,YAAQ,OAAO,KAAK,CAAC,QAAQ,OAAO,OAAO,CAAC;AAC5C,WAAO;AAAA,EACX;AAOE,WAAS,sBAAsB,WAAW,MAAM;AAC9C,cAAU,WAAW,KAAK,IAAI;AAAA,EAClC;AAOE,WAAS,kBAAkB,GAAG,MAAM;AAClC,SAAK,QAAS;AAAA,EAClB;AAUE,WAAS,iBAAiB,UAAU,QAAQ;AAC1C,WAAO;AAeP,aAAS,KAAK,YAAY,aAAa,YAAY;AAEjD,UAAI;AAEJ,UAAI;AAEJ,UAAI;AAEJ,UAAI;AACJ,aAAO,MAAM,QAAQ,UAAU;AAAA;AAAA,QAC/B,uBAAuB,UAAU;AAAA,UAAI,cAAc;AAAA;AAAA,QAEnD,uBAAuB;AAAA;AAAA,UAA0B;AAAA,QAAU,CAAE;AAAA,UAAI,sBAAsB,UAAU;AAUjG,eAAS,sBAAsB,KAAK;AAClC,eAAO;AAGP,iBAAS,MAAM,MAAM;AACnB,gBAAM,OAAO,SAAS,QAAQ,IAAI,IAAI;AACtC,gBAAM,MAAM,SAAS,QAAQ,IAAI;AACjC,gBAAM,OAAO;AAAA;AAAA;AAAA,YAGb,GAAI,MAAM,QAAQ,IAAI,IAAI,OAAO,OAAO,CAAC,IAAI,IAAI,CAAE;AAAA,YAAG,GAAI,MAAM,QAAQ,GAAG,IAAI,MAAM,MAAM,CAAC,GAAG,IAAI,CAAA;AAAA,UAAG;AACtG,iBAAO,uBAAuB,IAAI,EAAE,IAAI;AAAA,QAClD;AAAA,MACA;AAUM,eAAS,uBAAuB,MAAM;AACpC,2BAAmB;AACnB,yBAAiB;AACjB,YAAI,KAAK,WAAW,GAAG;AACrB,iBAAO;AAAA,QACjB;AACQ,eAAO,gBAAgB,KAAK,cAAc,CAAC;AAAA,MACnD;AAUM,eAAS,gBAAgB,WAAW;AAClC,eAAO;AAGP,iBAAS,MAAM,MAAM;AAKnB,iBAAO,MAAO;AACd,6BAAmB;AACnB,cAAI,CAAC,UAAU,SAAS;AACtB,oBAAQ,mBAAmB;AAAA,UACvC;AAIU,cAAI,UAAU,QAAQ,QAAQ,OAAO,WAAW,QAAQ,KAAK,SAAS,UAAU,IAAI,GAAG;AACrF,mBAAO,IAAQ;AAAA,UAC3B;AACU,iBAAO,UAAU,SAAS;AAAA;AAAA;AAAA;AAAA,YAI1B,SAAS,OAAO,OAAO,OAAO,OAAO,OAAO,GAAG,MAAM,IAAI;AAAA,YAAS;AAAA,YAAS;AAAA,YAAI;AAAA,UAAG,EAAE,IAAI;AAAA,QAClG;AAAA,MACA;AAGM,eAAS,GAAG,MAAM;AAEhB,iBAAS,kBAAkB,IAAI;AAC/B,eAAO;AAAA,MACf;AAGM,eAAS,IAAI,MAAM;AAEjB,aAAK,QAAS;AACd,YAAI,EAAE,iBAAiB,iBAAiB,QAAQ;AAC9C,iBAAO,gBAAgB,iBAAiB,cAAc,CAAC;AAAA,QACjE;AACQ,eAAO;AAAA,MACf;AAAA,IACA;AAAA,EACA;AAUE,WAAS,UAAU,WAAWA,OAAM;AAClC,QAAI,UAAU,cAAc,CAAC,qBAAqB,SAAS,SAAS,GAAG;AACrE,2BAAqB,KAAK,SAAS;AAAA,IACzC;AACI,QAAI,UAAU,SAAS;AACrB,aAAO,QAAQ,QAAQA,OAAM,QAAQ,OAAO,SAASA,OAAM,UAAU,QAAQ,QAAQ,OAAO,MAAMA,KAAI,GAAG,OAAO,CAAC;AAAA,IACvH;AACI,QAAI,UAAU,WAAW;AACvB,cAAQ,SAAS,UAAU,UAAU,QAAQ,QAAQ,OAAO;AAAA,IAClE;AAAA,EACA;AAQE,WAAS,QAAQ;AACf,UAAM,aAAa,IAAK;AACxB,UAAM,gBAAgB,QAAQ;AAC9B,UAAM,wBAAwB,QAAQ;AACtC,UAAM,mBAAmB,QAAQ,OAAO;AACxC,UAAM,aAAa,MAAM,KAAK,KAAK;AACnC,WAAO;AAAA,MACL,MAAM;AAAA,MACN;AAAA,IACD;AAQD,aAAS,UAAU;AACjB,cAAQ;AACR,cAAQ,WAAW;AACnB,cAAQ,mBAAmB;AAC3B,cAAQ,OAAO,SAAS;AACxB,cAAQ;AACR,8BAAyB;AAAA,IAC/B;AAAA,EACA;AASE,WAAS,0BAA0B;AACjC,QAAI,MAAM,QAAQ,eAAe,MAAM,SAAS,GAAG;AACjD,YAAM,SAAS,YAAY,MAAM,IAAI;AACrC,YAAM,UAAU,YAAY,MAAM,IAAI,IAAI;AAAA,IAChD;AAAA,EACA;AACA;AAYA,SAAS,YAAY,QAAQ,OAAO;AAClC,QAAM,aAAa,MAAM,MAAM;AAC/B,QAAM,mBAAmB,MAAM,MAAM;AACrC,QAAM,WAAW,MAAM,IAAI;AAC3B,QAAM,iBAAiB,MAAM,IAAI;AAEjC,MAAI;AACJ,MAAI,eAAe,UAAU;AAE3B,WAAO,CAAC,OAAO,UAAU,EAAE,MAAM,kBAAkB,cAAc,CAAC;AAAA,EACtE,OAAS;AACL,WAAO,OAAO,MAAM,YAAY,QAAQ;AACxC,QAAI,mBAAmB,IAAI;AACzB,YAAM,OAAO,KAAK,CAAC;AACnB,UAAI,OAAO,SAAS,UAAU;AAC5B,aAAK,CAAC,IAAI,KAAK,MAAM,gBAAgB;AAAA,MAE7C,OAAa;AACL,aAAK,MAAO;AAAA,MACpB;AAAA,IACA;AACI,QAAI,iBAAiB,GAAG;AAEtB,WAAK,KAAK,OAAO,QAAQ,EAAE,MAAM,GAAG,cAAc,CAAC;AAAA,IACzD;AAAA,EACA;AACE,SAAO;AACT;AAYA,SAAS,gBAAgB,QAAQ,YAAY;AAC3C,MAAI,QAAQ;AAEZ,QAAM,SAAS,CAAE;AAEjB,MAAI;AACJ,SAAO,EAAE,QAAQ,OAAO,QAAQ;AAC9B,UAAM,QAAQ,OAAO,KAAK;AAE1B,QAAI;AACJ,QAAI,OAAO,UAAU,UAAU;AAC7B,cAAQ;AAAA,IACT,MAAM,SAAQ,OAAK;AAAA,MAClB,KAAK,IACH;AACE,gBAAQ;AACR;AAAA,MACV;AAAA,MACM,KAAK,IACH;AACE,gBAAQ;AACR;AAAA,MACV;AAAA,MACM,KAAK,IACH;AACE,gBAAQ;AACR;AAAA,MACV;AAAA,MACM,KAAK,IACH;AACE,gBAAQ,aAAa,MAAM;AAC3B;AAAA,MACV;AAAA,MACM,KAAK,IACH;AACE,YAAI,CAAC,cAAc,MAAO;AAC1B,gBAAQ;AACR;AAAA,MACV;AAAA,MACM,SACE;AAEE,gBAAQ,OAAO,aAAa,KAAK;AAAA,MAC3C;AAAA,IACA;AACI,YAAQ,UAAU;AAClB,WAAO,KAAK,KAAK;AAAA,EACrB;AACE,SAAO,OAAO,KAAK,EAAE;AACvB;","x_google_ignoreList":[0]}