bitran/dist/_chunks/renderData-CZkwarYW.js

📜 Highly customizable text processor and transpiler.

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import { B as BlockNode, I as InlinerNode } from "./productNode-C0XZsQy2.js";
import { O as ObjBlockParseFactory, b as ObjProductStrFactory, d as defineProductCore, B as BlockParseFactory, a as ProductStrFactory, I as InlinerParseFactory, f as tryRange } from "./index-DiVYKXTv.js";
import { e as editorName, p as paragraphName, s as spanName } from "./shared-C10h7SVW.js";
class EditorParser extends ObjBlockParseFactory {
  constructor() {
    super(...arguments);
    __publicField(this, "objName", editorName);
  }
  async parseDataFromObj(obj) {
    if (!obj.src)
      throw new Error(`Missing editor string 'src' property!`);
    return {
      src: obj.src,
      content: await this.parseBlocks(obj.src)
    };
  }
}
class EditorStr extends ObjProductStrFactory {
  constructor() {
    super(...arguments);
    __publicField(this, "objName", editorName);
  }
  createObj(data) {
    return { src: data.src };
  }
}
class EditorNode extends BlockNode {
  constructor() {
    super(...arguments);
    __publicField(this, "name", editorName);
  }
}
const editor = defineProductCore({
  Node: EditorNode,
  Parser: EditorParser,
  Stringifier: EditorStr
});
class ParagraphParser extends BlockParseFactory {
  canParse() {
    return true;
  }
  async createParseData(strBlock) {
    return await this.parseInliners(strBlock);
  }
}
class ParagraphStr extends ProductStrFactory {
  stringifyData(data) {
    return this.stringify(data);
  }
}
class ParagraphNode extends BlockNode {
  constructor() {
    super(...arguments);
    __publicField(this, "name", paragraphName);
  }
  get children() {
    return [this.parseData];
  }
}
const paragraph = defineProductCore({
  Node: ParagraphNode,
  Parser: ParagraphParser,
  Stringifier: ParagraphStr
});
const startDelim = "<<";
const endDelim = ">>";
class SpanParser extends InlinerParseFactory {
  constructor() {
    super(...arguments);
    __publicField(this, "startDelim", startDelim);
    __publicField(this, "endDelim", endDelim);
  }
  outlineRanges(text) {
    const ranges = [];
    let regexp = new RegExp(`${this.startDelim}|${this.endDelim}`, "g");
    let openCount = 0;
    let cursor = 0;
    for (const match of text.matchAll(regexp)) {
      const offset = match.index;
      const openMatch = match[0] === this.startDelim;
      if (openCount === 0 && !openMatch)
        continue;
      if (openMatch) {
        if (openCount === 0)
          cursor = offset + this.startDelim.length;
        openCount++;
      }
      if (!openMatch) {
        openCount--;
        if (openCount === 0) {
          const range = tryRange(cursor - this.startDelim.length, offset + this.endDelim.length);
          if (range)
            ranges.push(range);
          cursor = offset + this.endDelim.length;
        }
      }
    }
    return ranges;
  }
  async createParseData(strInliner) {
    const strContent = strInliner.slice(startDelim.length, -1 * endDelim.length);
    return await this.parseInliners(strContent);
  }
}
class SpanStr extends ProductStrFactory {
  stringifyData(parseData) {
    return startDelim + this.stringify(parseData) + endDelim;
  }
}
class SpanNode extends InlinerNode {
  constructor() {
    super(...arguments);
    __publicField(this, "name", spanName);
  }
  get children() {
    return [this.parseData];
  }
}
const span = defineProductCore({
  Node: SpanNode,
  Parser: SpanParser,
  Stringifier: SpanStr
});
async function createRenderData(side, productNode, productCore) {
  const buildRenderData = productCore == null ? void 0 : productCore.buildRenderData;
  const wantedSide = productCore.renderDataSide;
  if (!buildRenderData)
    return void 0;
  if (wantedSide === "pre" && side === "front" || wantedSide === "front" && side === "pre")
    return void 0;
  try {
    const data = await buildRenderData({
      node: productNode,
      parseData: productNode.parseData,
      core: productCore
    });
    return {
      status: "success",
      data
    };
  } catch (error) {
    return {
      status: "error",
      errorMessage: (error == null ? void 0 : error.message) || error
    };
  }
}
export {
  EditorNode as E,
  ParagraphNode as P,
  SpanNode as S,
  createRenderData as c,
  editor as e,
  paragraph as p,
  span as s
};
//# sourceMappingURL=renderData-CZkwarYW.js.map