@fangzhongya/vue-archive 0.0.2-7 → 0.0.2

package/dist/es/node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/index.js

@@ -1,109 +1,182 @@
 import "./common/utils.js";
 import "./helpers/index.js";
-import u from "./renderer.js";
-import l from "./parser_core.js";
-import h from "./parser_block.js";
-import p from "./parser_inline.js";
-import m from "../../../../linkify-it@4.0.1/node_modules/linkify-it/index.js";
+import renderer from "./renderer.js";
+import parser_core from "./parser_core.js";
+import parser_block from "./parser_block.js";
+import parser_inline from "./parser_inline.js";
+import linkifyIt from "../../../../linkify-it@4.0.1/node_modules/linkify-it/index.js";
 import "../../../../mdurl@1.0.1/node_modules/mdurl/index.js";
-import d from "../../../../../../_virtual/punycode.es6.js";
-import k from "./presets/default.js";
-import w from "./presets/zero.js";
-import y from "./presets/commonmark.js";
-import { __exports as v } from "../../../../../../_virtual/utils.js";
-import { __exports as b } from "../../../../../../_virtual/index2.js";
-import { __exports as g } from "../../../../../../_virtual/index3.js";
-var s = v, _ = b, O = u, E = l, I = h, x = p, A = m, a = g, c = d, L = {
-  default: k,
-  zero: w,
-  commonmark: y
-}, S = /^(vbscript|javascript|file|data):/, z = /^data:image\/(gif|png|jpeg|webp);/;
-function R(r) {
-  var t = r.trim().toLowerCase();
-  return S.test(t) ? !!z.test(t) : !0;
+import require$$8 from "../../../../../../_virtual/punycode.es6.js";
+import _default from "./presets/default.js";
+import zero from "./presets/zero.js";
+import commonmark from "./presets/commonmark.js";
+import { __exports as utils$1 } from "../../../../../../_virtual/utils.js";
+import { __exports as helpers$1 } from "../../../../../../_virtual/index2.js";
+import { __exports as mdurl$1 } from "../../../../../../_virtual/index3.js";
+var utils = utils$1;
+var helpers = helpers$1;
+var Renderer = renderer;
+var ParserCore = parser_core;
+var ParserBlock = parser_block;
+var ParserInline = parser_inline;
+var LinkifyIt = linkifyIt;
+var mdurl = mdurl$1;
+var punycode = require$$8;
+var config = {
+  default: _default,
+  zero,
+  commonmark
+};
+var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
+var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
+function validateLink(url) {
+  var str = url.trim().toLowerCase();
+  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) ? true : false : true;
 }
-var f = ["http:", "https:", "mailto:"];
-function C(r) {
-  var t = a.parse(r, !0);
-  if (t.hostname && (!t.protocol || f.indexOf(t.protocol) >= 0))
-    try {
-      t.hostname = c.toASCII(t.hostname);
-    } catch {
+var RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
+function normalizeLink(url) {
+  var parsed = mdurl.parse(url, true);
+  if (parsed.hostname) {
+    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
+      try {
+        parsed.hostname = punycode.toASCII(parsed.hostname);
+      } catch (er) {
+      }
     }
-  return a.encode(a.format(t));
+  }
+  return mdurl.encode(mdurl.format(parsed));
 }
-function M(r) {
-  var t = a.parse(r, !0);
-  if (t.hostname && (!t.protocol || f.indexOf(t.protocol) >= 0))
-    try {
-      t.hostname = c.toUnicode(t.hostname);
-    } catch {
+function normalizeLinkText(url) {
+  var parsed = mdurl.parse(url, true);
+  if (parsed.hostname) {
+    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
+      try {
+        parsed.hostname = punycode.toUnicode(parsed.hostname);
+      } catch (er) {
+      }
     }
-  return a.decode(a.format(t), a.decode.defaultChars + "%");
+  }
+  return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + "%");
 }
-function n(r, t) {
-  if (!(this instanceof n))
-    return new n(r, t);
-  t || s.isString(r) || (t = r || {}, r = "default"), this.inline = new x(), this.block = new I(), this.core = new E(), this.renderer = new O(), this.linkify = new A(), this.validateLink = R, this.normalizeLink = C, this.normalizeLinkText = M, this.utils = s, this.helpers = s.assign({}, _), this.options = {}, this.configure(r), t && this.set(t);
+function MarkdownIt(presetName, options) {
+  if (!(this instanceof MarkdownIt)) {
+    return new MarkdownIt(presetName, options);
+  }
+  if (!options) {
+    if (!utils.isString(presetName)) {
+      options = presetName || {};
+      presetName = "default";
+    }
+  }
+  this.inline = new ParserInline();
+  this.block = new ParserBlock();
+  this.core = new ParserCore();
+  this.renderer = new Renderer();
+  this.linkify = new LinkifyIt();
+  this.validateLink = validateLink;
+  this.normalizeLink = normalizeLink;
+  this.normalizeLinkText = normalizeLinkText;
+  this.utils = utils;
+  this.helpers = utils.assign({}, helpers);
+  this.options = {};
+  this.configure(presetName);
+  if (options) {
+    this.set(options);
+  }
 }
-n.prototype.set = function(r) {
-  return s.assign(this.options, r), this;
+MarkdownIt.prototype.set = function(options) {
+  utils.assign(this.options, options);
+  return this;
 };
-n.prototype.configure = function(r) {
-  var t = this, e;
-  if (s.isString(r) && (e = r, r = L[e], !r))
-    throw new Error('Wrong `markdown-it` preset "' + e + '", check name');
-  if (!r)
+MarkdownIt.prototype.configure = function(presets) {
+  var self = this, presetName;
+  if (utils.isString(presets)) {
+    presetName = presets;
+    presets = config[presetName];
+    if (!presets) {
+      throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name');
+    }
+  }
+  if (!presets) {
     throw new Error("Wrong `markdown-it` preset, can't be empty");
-  return r.options && t.set(r.options), r.components && Object.keys(r.components).forEach(function(o) {
-    r.components[o].rules && t[o].ruler.enableOnly(r.components[o].rules), r.components[o].rules2 && t[o].ruler2.enableOnly(r.components[o].rules2);
-  }), this;
+  }
+  if (presets.options) {
+    self.set(presets.options);
+  }
+  if (presets.components) {
+    Object.keys(presets.components).forEach(function(name) {
+      if (presets.components[name].rules) {
+        self[name].ruler.enableOnly(presets.components[name].rules);
+      }
+      if (presets.components[name].rules2) {
+        self[name].ruler2.enableOnly(presets.components[name].rules2);
+      }
+    });
+  }
+  return this;
 };
-n.prototype.enable = function(r, t) {
-  var e = [];
-  Array.isArray(r) || (r = [r]), ["core", "block", "inline"].forEach(function(i) {
-    e = e.concat(this[i].ruler.enable(r, !0));
-  }, this), e = e.concat(this.inline.ruler2.enable(r, !0));
-  var o = r.filter(function(i) {
-    return e.indexOf(i) < 0;
+MarkdownIt.prototype.enable = function(list, ignoreInvalid) {
+  var result = [];
+  if (!Array.isArray(list)) {
+    list = [list];
+  }
+  ["core", "block", "inline"].forEach(function(chain) {
+    result = result.concat(this[chain].ruler.enable(list, true));
+  }, this);
+  result = result.concat(this.inline.ruler2.enable(list, true));
+  var missed = list.filter(function(name) {
+    return result.indexOf(name) < 0;
   });
-  if (o.length && !t)
-    throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + o);
+  if (missed.length && !ignoreInvalid) {
+    throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + missed);
+  }
   return this;
 };
-n.prototype.disable = function(r, t) {
-  var e = [];
-  Array.isArray(r) || (r = [r]), ["core", "block", "inline"].forEach(function(i) {
-    e = e.concat(this[i].ruler.disable(r, !0));
-  }, this), e = e.concat(this.inline.ruler2.disable(r, !0));
-  var o = r.filter(function(i) {
-    return e.indexOf(i) < 0;
+MarkdownIt.prototype.disable = function(list, ignoreInvalid) {
+  var result = [];
+  if (!Array.isArray(list)) {
+    list = [list];
+  }
+  ["core", "block", "inline"].forEach(function(chain) {
+    result = result.concat(this[chain].ruler.disable(list, true));
+  }, this);
+  result = result.concat(this.inline.ruler2.disable(list, true));
+  var missed = list.filter(function(name) {
+    return result.indexOf(name) < 0;
   });
-  if (o.length && !t)
-    throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + o);
+  if (missed.length && !ignoreInvalid) {
+    throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + missed);
+  }
   return this;
 };
-n.prototype.use = function(r) {
-  var t = [this].concat(Array.prototype.slice.call(arguments, 1));
-  return r.apply(r, t), this;
+MarkdownIt.prototype.use = function(plugin) {
+  var args = [this].concat(Array.prototype.slice.call(arguments, 1));
+  plugin.apply(plugin, args);
+  return this;
 };
-n.prototype.parse = function(r, t) {
-  if (typeof r != "string")
+MarkdownIt.prototype.parse = function(src, env) {
+  if (typeof src !== "string") {
     throw new Error("Input data should be a String");
-  var e = new this.core.State(r, this, t);
-  return this.core.process(e), e.tokens;
+  }
+  var state = new this.core.State(src, this, env);
+  this.core.process(state);
+  return state.tokens;
 };
-n.prototype.render = function(r, t) {
-  return t = t || {}, this.renderer.render(this.parse(r, t), this.options, t);
+MarkdownIt.prototype.render = function(src, env) {
+  env = env || {};
+  return this.renderer.render(this.parse(src, env), this.options, env);
 };
-n.prototype.parseInline = function(r, t) {
-  var e = new this.core.State(r, this, t);
-  return e.inlineMode = !0, this.core.process(e), e.tokens;
+MarkdownIt.prototype.parseInline = function(src, env) {
+  var state = new this.core.State(src, this, env);
+  state.inlineMode = true;
+  this.core.process(state);
+  return state.tokens;
 };
-n.prototype.renderInline = function(r, t) {
-  return t = t || {}, this.renderer.render(this.parseInline(r, t), this.options, t);
+MarkdownIt.prototype.renderInline = function(src, env) {
+  env = env || {};
+  return this.renderer.render(this.parseInline(src, env), this.options, env);
 };
-var V = n;
+var lib = MarkdownIt;
 export {
-  V as default
+  lib as default
 };

package/dist/es/node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_block.js

@@ -1,53 +1,80 @@
-import h from "./ruler.js";
-import u from "./rules_block/table.js";
-import k from "./rules_block/code.js";
-import b from "./rules_block/fence.js";
-import g from "./rules_block/blockquote.js";
-import s from "./rules_block/hr.js";
-import q from "./rules_block/list.js";
-import v from "./rules_block/reference.js";
-import y from "./rules_block/html_block.js";
-import d from "./rules_block/heading.js";
-import _ from "./rules_block/lheading.js";
-import x from "./rules_block/paragraph.js";
-import E from "./rules_block/state_block.js";
-var w = h, t = [
+import ruler from "./ruler.js";
+import table from "./rules_block/table.js";
+import code from "./rules_block/code.js";
+import fence from "./rules_block/fence.js";
+import blockquote from "./rules_block/blockquote.js";
+import hr from "./rules_block/hr.js";
+import list from "./rules_block/list.js";
+import reference from "./rules_block/reference.js";
+import html_block from "./rules_block/html_block.js";
+import heading from "./rules_block/heading.js";
+import lheading from "./rules_block/lheading.js";
+import paragraph from "./rules_block/paragraph.js";
+import state_block from "./rules_block/state_block.js";
+var Ruler = ruler;
+var _rules = [
   // First 2 params - rule name & source. Secondary array - list of rules,
   // which can be terminated by this one.
-  ["table", u, ["paragraph", "reference"]],
-  ["code", k],
-  ["fence", b, ["paragraph", "reference", "blockquote", "list"]],
-  ["blockquote", g, ["paragraph", "reference", "blockquote", "list"]],
-  ["hr", s, ["paragraph", "reference", "blockquote", "list"]],
-  ["list", q, ["paragraph", "reference", "blockquote"]],
-  ["reference", v],
-  ["html_block", y, ["paragraph", "reference", "blockquote"]],
-  ["heading", d, ["paragraph", "reference", "blockquote"]],
-  ["lheading", _],
-  ["paragraph", x]
+  ["table", table, ["paragraph", "reference"]],
+  ["code", code],
+  ["fence", fence, ["paragraph", "reference", "blockquote", "list"]],
+  ["blockquote", blockquote, ["paragraph", "reference", "blockquote", "list"]],
+  ["hr", hr, ["paragraph", "reference", "blockquote", "list"]],
+  ["list", list, ["paragraph", "reference", "blockquote"]],
+  ["reference", reference],
+  ["html_block", html_block, ["paragraph", "reference", "blockquote"]],
+  ["heading", heading, ["paragraph", "reference", "blockquote"]],
+  ["lheading", lheading],
+  ["paragraph", paragraph]
 ];
-function p() {
-  this.ruler = new w();
-  for (var r = 0; r < t.length; r++)
-    this.ruler.push(t[r][0], t[r][1], { alt: (t[r][2] || []).slice() });
+function ParserBlock() {
+  this.ruler = new Ruler();
+  for (var i = 0; i < _rules.length; i++) {
+    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });
+  }
 }
-p.prototype.tokenize = function(r, a, l) {
-  for (var i, o, n = this.ruler.getRules(""), m = n.length, e = a, f = !1, c = r.md.options.maxNesting; e < l && (r.line = e = r.skipEmptyLines(e), !(e >= l || r.sCount[e] < r.blkIndent)); ) {
-    if (r.level >= c) {
-      r.line = l;
+ParserBlock.prototype.tokenize = function(state, startLine, endLine) {
+  var ok, i, rules = this.ruler.getRules(""), len = rules.length, line = startLine, hasEmptyLines = false, maxNesting = state.md.options.maxNesting;
+  while (line < endLine) {
+    state.line = line = state.skipEmptyLines(line);
+    if (line >= endLine) {
+      break;
+    }
+    if (state.sCount[line] < state.blkIndent) {
+      break;
+    }
+    if (state.level >= maxNesting) {
+      state.line = endLine;
       break;
     }
-    for (o = 0; o < m && (i = n[o](r, e, l, !1), !i); o++)
-      ;
-    r.tight = !f, r.isEmpty(r.line - 1) && (f = !0), e = r.line, e < l && r.isEmpty(e) && (f = !0, e++, r.line = e);
+    for (i = 0; i < len; i++) {
+      ok = rules[i](state, line, endLine, false);
+      if (ok) {
+        break;
+      }
+    }
+    state.tight = !hasEmptyLines;
+    if (state.isEmpty(state.line - 1)) {
+      hasEmptyLines = true;
+    }
+    line = state.line;
+    if (line < endLine && state.isEmpty(line)) {
+      hasEmptyLines = true;
+      line++;
+      state.line = line;
+    }
   }
 };
-p.prototype.parse = function(r, a, l, i) {
-  var o;
-  r && (o = new this.State(r, a, l, i), this.tokenize(o, o.line, o.lineMax));
+ParserBlock.prototype.parse = function(src, md, env, outTokens) {
+  var state;
+  if (!src) {
+    return;
+  }
+  state = new this.State(src, md, env, outTokens);
+  this.tokenize(state, state.line, state.lineMax);
 };
-p.prototype.State = E;
-var G = p;
+ParserBlock.prototype.State = state_block;
+var parser_block = ParserBlock;
 export {
-  G as default
+  parser_block as default
 };

package/dist/es/node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_core.js

@@ -1,35 +1,39 @@
-import l from "./ruler.js";
-import n from "./rules_core/normalize.js";
-import p from "./rules_core/block.js";
-import s from "./rules_core/inline.js";
-import a from "./rules_core/linkify.js";
-import f from "./rules_core/replacements.js";
-import u from "./rules_core/smartquotes.js";
-import c from "./rules_core/text_join.js";
-import h from "./rules_core/state_core.js";
-var v = l, t = [
-  ["normalize", n],
-  ["block", p],
-  ["inline", s],
-  ["linkify", a],
-  ["replacements", f],
-  ["smartquotes", u],
+import ruler from "./ruler.js";
+import normalize from "./rules_core/normalize.js";
+import block from "./rules_core/block.js";
+import inline from "./rules_core/inline.js";
+import linkify from "./rules_core/linkify.js";
+import replacements from "./rules_core/replacements.js";
+import smartquotes from "./rules_core/smartquotes.js";
+import text_join from "./rules_core/text_join.js";
+import state_core from "./rules_core/state_core.js";
+var Ruler = ruler;
+var _rules = [
+  ["normalize", normalize],
+  ["block", block],
+  ["inline", inline],
+  ["linkify", linkify],
+  ["replacements", replacements],
+  ["smartquotes", smartquotes],
   // `text_join` finds `text_special` tokens (for escape sequences)
   // and joins them with the rest of the text
-  ["text_join", c]
+  ["text_join", text_join]
 ];
-function i() {
-  this.ruler = new v();
-  for (var r = 0; r < t.length; r++)
-    this.ruler.push(t[r][0], t[r][1]);
+function Core() {
+  this.ruler = new Ruler();
+  for (var i = 0; i < _rules.length; i++) {
+    this.ruler.push(_rules[i][0], _rules[i][1]);
+  }
 }
-i.prototype.process = function(r) {
-  var o, m, e;
-  for (e = this.ruler.getRules(""), o = 0, m = e.length; o < m; o++)
-    e[o](r);
+Core.prototype.process = function(state) {
+  var i, l, rules;
+  rules = this.ruler.getRules("");
+  for (i = 0, l = rules.length; i < l; i++) {
+    rules[i](state);
+  }
 };
-i.prototype.State = h;
-var R = i;
+Core.prototype.State = state_core;
+var parser_core = Core;
 export {
-  R as default
+  parser_core as default
 };

package/dist/es/node_modules/.pnpm/markdown-it@13.0.1/node_modules/markdown-it/lib/parser_inline.js

@@ -1,83 +1,113 @@
-import k from "./ruler.js";
-import g from "./rules_inline/text.js";
-import c from "./rules_inline/linkify.js";
-import _ from "./rules_inline/newline.js";
-import v from "./rules_inline/escape.js";
-import x from "./rules_inline/backticks.js";
+import ruler from "./ruler.js";
+import text from "./rules_inline/text.js";
+import linkify from "./rules_inline/linkify.js";
+import newline from "./rules_inline/newline.js";
+import _escape from "./rules_inline/escape.js";
+import backticks from "./rules_inline/backticks.js";
 import "./rules_inline/strikethrough.js";
 import "./rules_inline/emphasis.js";
-import d from "./rules_inline/link.js";
-import y from "./rules_inline/image.js";
-import b from "./rules_inline/autolink.js";
-import w from "./rules_inline/html_inline.js";
-import z from "./rules_inline/entity.js";
-import N from "./rules_inline/balance_pairs.js";
-import P from "./rules_inline/fragments_join.js";
-import R from "./rules_inline/state_inline.js";
-import { __exports as h } from "../../../../../../_virtual/strikethrough.js";
-import { __exports as a } from "../../../../../../_virtual/emphasis.js";
-var u = k, m = [
-  ["text", g],
-  ["linkify", c],
-  ["newline", _],
-  ["escape", v],
-  ["backticks", x],
-  ["strikethrough", h.tokenize],
-  ["emphasis", a.tokenize],
-  ["link", d],
-  ["image", y],
-  ["autolink", b],
-  ["html_inline", w],
-  ["entity", z]
-], f = [
-  ["balance_pairs", N],
-  ["strikethrough", h.postProcess],
-  ["emphasis", a.postProcess],
+import link from "./rules_inline/link.js";
+import image from "./rules_inline/image.js";
+import autolink from "./rules_inline/autolink.js";
+import html_inline from "./rules_inline/html_inline.js";
+import entity from "./rules_inline/entity.js";
+import balance_pairs from "./rules_inline/balance_pairs.js";
+import fragments_join from "./rules_inline/fragments_join.js";
+import state_inline from "./rules_inline/state_inline.js";
+import { __exports as strikethrough } from "../../../../../../_virtual/strikethrough.js";
+import { __exports as emphasis } from "../../../../../../_virtual/emphasis.js";
+var Ruler = ruler;
+var _rules = [
+  ["text", text],
+  ["linkify", linkify],
+  ["newline", newline],
+  ["escape", _escape],
+  ["backticks", backticks],
+  ["strikethrough", strikethrough.tokenize],
+  ["emphasis", emphasis.tokenize],
+  ["link", link],
+  ["image", image],
+  ["autolink", autolink],
+  ["html_inline", html_inline],
+  ["entity", entity]
+];
+var _rules2 = [
+  ["balance_pairs", balance_pairs],
+  ["strikethrough", strikethrough.postProcess],
+  ["emphasis", emphasis.postProcess],
   // rules for pairs separate '**' into its own text tokens, which may be left unused,
   // rule below merges unused segments back with the rest of the text
-  ["fragments_join", P]
+  ["fragments_join", fragments_join]
 ];
-function s() {
-  var r;
-  for (this.ruler = new u(), r = 0; r < m.length; r++)
-    this.ruler.push(m[r][0], m[r][1]);
-  for (this.ruler2 = new u(), r = 0; r < f.length; r++)
-    this.ruler2.push(f[r][0], f[r][1]);
+function ParserInline() {
+  var i;
+  this.ruler = new Ruler();
+  for (i = 0; i < _rules.length; i++) {
+    this.ruler.push(_rules[i][0], _rules[i][1]);
+  }
+  this.ruler2 = new Ruler();
+  for (i = 0; i < _rules2.length; i++) {
+    this.ruler2.push(_rules2[i][0], _rules2[i][1]);
+  }
 }
-s.prototype.skipToken = function(r) {
-  var i, e, n = r.pos, o = this.ruler.getRules(""), p = o.length, t = r.md.options.maxNesting, l = r.cache;
-  if (typeof l[n] < "u") {
-    r.pos = l[n];
+ParserInline.prototype.skipToken = function(state) {
+  var ok, i, pos = state.pos, rules = this.ruler.getRules(""), len = rules.length, maxNesting = state.md.options.maxNesting, cache = state.cache;
+  if (typeof cache[pos] !== "undefined") {
+    state.pos = cache[pos];
     return;
   }
-  if (r.level < t)
-    for (e = 0; e < p && (r.level++, i = o[e](r, !0), r.level--, !i); e++)
-      ;
-  else
-    r.pos = r.posMax;
-  i || r.pos++, l[n] = r.pos;
+  if (state.level < maxNesting) {
+    for (i = 0; i < len; i++) {
+      state.level++;
+      ok = rules[i](state, true);
+      state.level--;
+      if (ok) {
+        break;
+      }
+    }
+  } else {
+    state.pos = state.posMax;
+  }
+  if (!ok) {
+    state.pos++;
+  }
+  cache[pos] = state.pos;
 };
-s.prototype.tokenize = function(r) {
-  for (var i, e, n = this.ruler.getRules(""), o = n.length, p = r.posMax, t = r.md.options.maxNesting; r.pos < p; ) {
-    if (r.level < t)
-      for (e = 0; e < o && (i = n[e](r, !1), !i); e++)
-        ;
-    if (i) {
-      if (r.pos >= p)
+ParserInline.prototype.tokenize = function(state) {
+  var ok, i, rules = this.ruler.getRules(""), len = rules.length, end = state.posMax, maxNesting = state.md.options.maxNesting;
+  while (state.pos < end) {
+    if (state.level < maxNesting) {
+      for (i = 0; i < len; i++) {
+        ok = rules[i](state, false);
+        if (ok) {
+          break;
+        }
+      }
+    }
+    if (ok) {
+      if (state.pos >= end) {
         break;
+      }
       continue;
     }
-    r.pending += r.src[r.pos++];
+    state.pending += state.src[state.pos++];
+  }
+  if (state.pending) {
+    state.pushPending();
   }
-  r.pending && r.pushPending();
 };
-s.prototype.parse = function(r, i, e, n) {
-  var o, p, t, l = new this.State(r, i, e, n);
-  for (this.tokenize(l), p = this.ruler2.getRules(""), t = p.length, o = 0; o < t; o++)
-    p[o](l);
+ParserInline.prototype.parse = function(str, md, env, outTokens) {
+  var i, rules, len;
+  var state = new this.State(str, md, env, outTokens);
+  this.tokenize(state);
+  rules = this.ruler2.getRules("");
+  len = rules.length;
+  for (i = 0; i < len; i++) {
+    rules[i](state);
+  }
 };
-s.prototype.State = R;
-var Q = s;
+ParserInline.prototype.State = state_inline;
+var parser_inline = ParserInline;
 export {
-  Q as default
+  parser_inline as default
 };