@mlightcad/mtext-parser 1.0.0 → 1.0.1

package/dist/parser.es.js

@@ -0,0 +1,707 @@
+var x = /* @__PURE__ */ ((s) => (s[s.NONE = 0] = "NONE", s[s.WORD = 1] = "WORD", s[s.STACK = 2] = "STACK", s[s.SPACE = 3] = "SPACE", s[s.NBSP = 4] = "NBSP", s[s.TABULATOR = 5] = "TABULATOR", s[s.NEW_PARAGRAPH = 6] = "NEW_PARAGRAPH", s[s.NEW_COLUMN = 7] = "NEW_COLUMN", s[s.WRAP_AT_DIMLINE = 8] = "WRAP_AT_DIMLINE", s[s.PROPERTIES_CHANGED = 9] = "PROPERTIES_CHANGED", s))(x || {}), g = /* @__PURE__ */ ((s) => (s[s.BOTTOM = 0] = "BOTTOM", s[s.MIDDLE = 1] = "MIDDLE", s[s.TOP = 2] = "TOP", s))(g || {}), E = /* @__PURE__ */ ((s) => (s[s.DEFAULT = 0] = "DEFAULT", s[s.LEFT = 1] = "LEFT", s[s.RIGHT = 2] = "RIGHT", s[s.CENTER = 3] = "CENTER", s[s.JUSTIFIED = 4] = "JUSTIFIED", s[s.DISTRIBUTED = 5] = "DISTRIBUTED", s))(E || {}), m = /* @__PURE__ */ ((s) => (s[s.NONE = 0] = "NONE", s[s.UNDERLINE = 1] = "UNDERLINE", s[s.OVERLINE = 2] = "OVERLINE", s[s.STRIKE_THROUGH = 4] = "STRIKE_THROUGH", s))(m || {});
+const b = {
+  c: "Ø",
+  d: "°",
+  p: "±"
+}, w = {
+  l: 1,
+  r: 2,
+  c: 3,
+  j: 4,
+  d: 5
+  /* DISTRIBUTED */
+};
+function I(s) {
+  const [e, t, r] = s;
+  return r << 16 | t << 8 | e;
+}
+function _(s) {
+  const e = s & 255, t = s >> 8 & 255, r = s >> 16 & 255;
+  return [e, t, r];
+}
+function S(s) {
+  return s.replace(/\^(.)/g, (e, t) => {
+    const r = t.charCodeAt(0);
+    return r === 32 ? "^" : r === 73 ? "	" : r === 74 ? `
+` : r === 77 ? "" : "▯";
+  });
+}
+function F(s) {
+  return s.replace(/\r\n|\r|\n/g, "\\P");
+}
+function C(s) {
+  return s.replace(/\\P/g, "").replace(/\\~/g, "").includes("\\");
+}
+class N {
+  /**
+   * Creates a new MTextParser instance
+   * @param content - The MText content to parse
+   * @param ctx - Optional initial MText context
+   * @param yieldPropertyCommands - Whether to yield property change commands
+   */
+  constructor(e, t, r = !1) {
+    this.ctxStack = [], this.continueStroke = !1, this.scanner = new p(S(e)), this.ctx = t ?? new d(), this.yieldPropertyCommands = r, this.decoder = new TextDecoder("gbk");
+  }
+  /**
+   * Decode multi-byte character from hex code
+   * @param hex - Hex code string (e.g. "C4E3")
+   * @returns Decoded character or empty square if invalid
+   */
+  decodeMultiByteChar(e) {
+    try {
+      const t = new Uint8Array([
+        parseInt(e.substr(0, 2), 16),
+        parseInt(e.substr(2, 2), 16)
+      ]);
+      return this.decoder.decode(t);
+    } catch {
+      return "▯";
+    }
+  }
+  /**
+   * Push current context onto the stack
+   */
+  pushCtx() {
+    this.ctxStack.push(this.ctx);
+  }
+  /**
+   * Pop context from the stack
+   */
+  popCtx() {
+    this.ctxStack.length > 0 && (this.ctx = this.ctxStack.pop());
+  }
+  /**
+   * Parse stacking expression (numerator/denominator)
+   * @returns Tuple of [TokenType.STACK, [numerator, denominator, type]]
+   */
+  parseStacking() {
+    const e = new p(this.extractExpression(!0));
+    let t = "", r = "", a = "";
+    const n = () => {
+      let i = e.peek(), o = !1;
+      return i.charCodeAt(0) < 32 && (i = " "), i === "\\" && (o = !0, e.consume(1), i = e.peek()), e.consume(1), [i, o];
+    }, c = () => {
+      let i = "";
+      for (; e.hasData; ) {
+        const [o, h] = n();
+        if (!h && "^/#".includes(o))
+          return [i, o];
+        i += o;
+      }
+      return [i, ""];
+    }, l = () => {
+      let i = "";
+      for (; e.hasData; ) {
+        const [o, h] = n();
+        h && o === ";" ? i += ";" : i += o;
+      }
+      return i;
+    };
+    return [t, a] = c(), a && (r = l()), [2, [t, r, a]];
+  }
+  /**
+   * Parse MText properties
+   * @param cmd - The property command to parse
+   */
+  parseProperties(e) {
+    const t = this.ctx.copy();
+    switch (e) {
+      case "L":
+        t.underline = !0, this.continueStroke = !0;
+        break;
+      case "l":
+        t.underline = !1, t.hasAnyStroke || (this.continueStroke = !1);
+        break;
+      case "O":
+        t.overline = !0, this.continueStroke = !0;
+        break;
+      case "o":
+        t.overline = !1, t.hasAnyStroke || (this.continueStroke = !1);
+        break;
+      case "K":
+        t.strikeThrough = !0, this.continueStroke = !0;
+        break;
+      case "k":
+        t.strikeThrough = !1, t.hasAnyStroke || (this.continueStroke = !1);
+        break;
+      case "A":
+        this.parseAlign(t);
+        break;
+      case "C":
+        this.parseAciColor(t);
+        break;
+      case "c":
+        this.parseRgbColor(t);
+        break;
+      case "H":
+        this.parseHeight(t);
+        break;
+      case "W":
+        this.parseWidth(t);
+        break;
+      case "Q":
+        this.parseOblique(t);
+        break;
+      case "T":
+        this.parseCharTracking(t);
+        break;
+      case "p":
+        this.parseParagraphProperties(t);
+        break;
+      case "f":
+      case "F":
+        this.parseFontProperties(t);
+        break;
+      default:
+        throw new Error(`Unknown command: ${e}`);
+    }
+    t.continueStroke = this.continueStroke, this.ctx = t;
+  }
+  /**
+   * Parse alignment property
+   * @param ctx - The context to update
+   */
+  parseAlign(e) {
+    const t = this.scanner.get();
+    "012".includes(t) ? e.align = parseInt(t) : e.align = 0, this.consumeOptionalTerminator();
+  }
+  /**
+   * Parse height property
+   * @param ctx - The context to update
+   */
+  parseHeight(e) {
+    const t = this.extractFloatExpression(!0);
+    if (t)
+      try {
+        t.endsWith("x") ? e.capHeight = Math.abs(parseFloat(t.slice(0, -1))) : e.capHeight = Math.abs(parseFloat(t));
+      } catch {
+        this.scanner.consume(-t.length);
+        return;
+      }
+    this.consumeOptionalTerminator();
+  }
+  /**
+   * Parse width property
+   * @param ctx - The context to update
+   */
+  parseWidth(e) {
+    const t = this.extractFloatExpression(!0);
+    if (t)
+      try {
+        t.endsWith("x") ? e.widthFactor = Math.abs(parseFloat(t.slice(0, -1))) : e.widthFactor = Math.abs(parseFloat(t));
+      } catch {
+        this.scanner.consume(-t.length);
+        return;
+      }
+    this.consumeOptionalTerminator();
+  }
+  /**
+   * Parse character tracking property
+   * @param ctx - The context to update
+   */
+  parseCharTracking(e) {
+    const t = this.extractFloatExpression(!0);
+    if (t)
+      try {
+        t.endsWith("x") ? e.charTrackingFactor = Math.abs(parseFloat(t.slice(0, -1))) : e.charTrackingFactor = Math.abs(parseFloat(t));
+      } catch {
+        this.scanner.consume(-t.length);
+        return;
+      }
+    this.consumeOptionalTerminator();
+  }
+  /**
+   * Parse float value or factor
+   * @param value - Current value to apply factor to
+   * @returns New value
+   */
+  parseFloatValueOrFactor(e) {
+    const t = this.extractFloatExpression(!0);
+    if (t)
+      if (t.endsWith("x")) {
+        const r = parseFloat(t.slice(0, -1));
+        e *= Math.abs(r);
+      } else
+        e = Math.abs(parseFloat(t));
+    return e;
+  }
+  /**
+   * Parse oblique angle property
+   * @param ctx - The context to update
+   */
+  parseOblique(e) {
+    const t = this.extractFloatExpression(!1);
+    t && (e.oblique = parseFloat(t)), this.consumeOptionalTerminator();
+  }
+  /**
+   * Parse ACI color property
+   * @param ctx - The context to update
+   */
+  parseAciColor(e) {
+    const t = this.extractIntExpression();
+    if (t) {
+      const r = parseInt(t);
+      r < 257 && (e.aci = r, e.rgb = null);
+    }
+    this.consumeOptionalTerminator();
+  }
+  /**
+   * Parse RGB color property
+   * @param ctx - The context to update
+   */
+  parseRgbColor(e) {
+    const t = this.extractIntExpression();
+    if (t) {
+      const r = parseInt(t) & 16777215, [a, n, c] = _(r);
+      e.rgb = [c, n, a];
+    }
+    this.consumeOptionalTerminator();
+  }
+  /**
+   * Extract float expression from scanner
+   * @param relative - Whether to allow relative values (ending in 'x')
+   * @returns Extracted expression
+   */
+  extractFloatExpression(e = !1) {
+    const t = e ? /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?x?/ : /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/, r = this.scanner.tail.match(t);
+    if (r) {
+      const a = r[0];
+      return this.scanner.consume(a.length), a;
+    }
+    return "";
+  }
+  /**
+   * Extract integer expression from scanner
+   * @returns Extracted expression
+   */
+  extractIntExpression() {
+    const e = this.scanner.tail.match(/^\d+/);
+    if (e) {
+      const t = e[0];
+      return this.scanner.consume(t.length), t;
+    }
+    return "";
+  }
+  /**
+   * Extract expression until semicolon or end
+   * @param escape - Whether to handle escaped semicolons
+   * @returns Extracted expression
+   */
+  extractExpression(e = !1) {
+    const t = this.scanner.find(";", e);
+    if (t < 0) {
+      const c = this.scanner.tail;
+      return this.scanner.consume(c.length), c;
+    }
+    const a = this.scanner.peek(t - this.scanner.currentIndex - 1) === "\\", n = this.scanner.tail.slice(0, t - this.scanner.currentIndex + (a ? 1 : 0));
+    return this.scanner.consume(n.length + 1), n;
+  }
+  /**
+   * Parse font properties
+   * @param ctx - The context to update
+   */
+  parseFontProperties(e) {
+    const t = this.extractExpression().split("|");
+    if (t.length > 0 && t[0]) {
+      const r = t[0];
+      let a = "Regular", n = 400;
+      for (const c of t.slice(1))
+        c.startsWith("b1") ? n = 700 : c.startsWith("i1") && (a = "Italic");
+      e.fontFace = {
+        family: r,
+        style: a,
+        weight: n
+      };
+    }
+  }
+  /**
+   * Parse paragraph properties from the MText content
+   * Handles properties like indentation, alignment, and tab stops
+   * @param ctx - The context to update
+   */
+  parseParagraphProperties(e) {
+    const t = new p(this.extractExpression());
+    let r = e.paragraph.indent, a = e.paragraph.left, n = e.paragraph.right, c = e.paragraph.align, l = [];
+    const i = () => {
+      const o = t.tail.match(/^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?/);
+      if (o) {
+        const h = parseFloat(o[0]);
+        for (t.consume(o[0].length); t.peek() === ","; )
+          t.consume(1);
+        return h;
+      }
+      return 0;
+    };
+    for (; t.hasData; )
+      switch (t.get()) {
+        case "i":
+          r = i();
+          break;
+        case "l":
+          a = i();
+          break;
+        case "r":
+          n = i();
+          break;
+        case "x":
+          break;
+        case "q": {
+          const h = t.get();
+          for (c = w[h] || 0; t.peek() === ","; )
+            t.consume(1);
+          break;
+        }
+        case "t":
+          for (l = []; t.hasData; ) {
+            const h = t.peek();
+            if (h === "r" || h === "c") {
+              t.consume(1);
+              const u = i();
+              l.push(h + u.toString());
+            } else {
+              const u = i();
+              isNaN(u) ? t.consume(1) : l.push(u);
+            }
+          }
+          break;
+      }
+    e.paragraph = {
+      indent: r,
+      left: a,
+      right: n,
+      align: c,
+      tab_stops: l
+    };
+  }
+  /**
+   * Consume optional terminator (semicolon)
+   */
+  consumeOptionalTerminator() {
+    this.scanner.peek() === ";" && this.scanner.consume(1);
+  }
+  /**
+   * Parse MText content into tokens
+   * @yields MTextToken objects
+   */
+  *parse() {
+    let r = null;
+    const a = () => {
+      var c;
+      let n = "";
+      for (; this.scanner.hasData; ) {
+        let l = !1, i = this.scanner.peek();
+        const o = this.scanner.currentIndex;
+        if (i.charCodeAt(0) < 32) {
+          if (this.scanner.consume(1), i === "	")
+            return [5, null];
+          if (i === `
+`)
+            return [6, null];
+          i = " ";
+        }
+        if (i === "\\")
+          if ("\\{}".includes(this.scanner.peek(1)))
+            l = !0, this.scanner.consume(1), i = this.scanner.peek();
+          else {
+            if (n)
+              return [1, n];
+            this.scanner.consume(1);
+            const h = this.scanner.get();
+            switch (h) {
+              case "~":
+                return [4, null];
+              case "P":
+                return [6, null];
+              case "N":
+                return [7, null];
+              case "X":
+                return [8, null];
+              case "S":
+                return this.parseStacking();
+              case "m":
+              case "M":
+                if (this.scanner.peek() === "+") {
+                  this.scanner.consume(1);
+                  const u = (c = this.scanner.tail.match(/^[0-9A-Fa-f]{4}/)) == null ? void 0 : c[0];
+                  if (u) {
+                    this.scanner.consume(4);
+                    const k = this.decodeMultiByteChar(u);
+                    return n ? [1, n] : [1, k];
+                  }
+                  this.scanner.consume(-1);
+                }
+                n += "\\M";
+                continue;
+              default:
+                if (h)
+                  try {
+                    if (this.parseProperties(h), this.yieldPropertyCommands)
+                      return [
+                        9,
+                        this.scanner.tail.slice(o, this.scanner.currentIndex)
+                      ];
+                    continue;
+                  } catch {
+                    const u = this.scanner.tail.slice(
+                      o,
+                      this.scanner.currentIndex
+                    );
+                    n += u;
+                  }
+            }
+            continue;
+          }
+        if (i === "%" && this.scanner.peek(1) === "%") {
+          const h = this.scanner.peek(2).toLowerCase(), u = b[h];
+          if (u) {
+            this.scanner.consume(3), n += u;
+            continue;
+          } else {
+            this.scanner.consume(3);
+            continue;
+          }
+        }
+        if (i === " ")
+          return n ? (this.scanner.consume(1), r = 3, [1, n]) : (this.scanner.consume(1), [3, null]);
+        if (!l) {
+          if (i === "{") {
+            if (n)
+              return [1, n];
+            this.scanner.consume(1), this.pushCtx();
+            continue;
+          } else if (i === "}") {
+            if (n)
+              return [1, n];
+            this.scanner.consume(1), this.popCtx();
+            continue;
+          }
+        }
+        this.scanner.consume(1), i.charCodeAt(0) >= 32 && (n += i);
+      }
+      return n ? [1, n] : [0, null];
+    };
+    for (; ; ) {
+      const [n, c] = a();
+      if (n)
+        yield new f(n, this.ctx, c), r && (yield new f(r, this.ctx, null), r = null);
+      else
+        break;
+    }
+  }
+}
+class p {
+  /**
+   * Create a new text scanner
+   * @param text - The text to scan
+   */
+  constructor(e) {
+    this.text = e, this.textLen = e.length, this._index = 0;
+  }
+  /**
+   * Get the current index in the text
+   */
+  get currentIndex() {
+    return this._index;
+  }
+  /**
+   * Check if the scanner has reached the end of the text
+   */
+  get isEmpty() {
+    return this._index >= this.textLen;
+  }
+  /**
+   * Check if there is more text to scan
+   */
+  get hasData() {
+    return this._index < this.textLen;
+  }
+  /**
+   * Get the next character and advance the index
+   * @returns The next character, or empty string if at end
+   */
+  get() {
+    if (this.isEmpty)
+      return "";
+    const e = this.text[this._index];
+    return this._index++, e;
+  }
+  /**
+   * Advance the index by the specified count
+   * @param count - Number of characters to advance
+   */
+  consume(e = 1) {
+    this._index = Math.max(0, Math.min(this._index + e, this.textLen));
+  }
+  /**
+   * Look at a character without advancing the index
+   * @param offset - Offset from current position
+   * @returns The character at the offset position, or empty string if out of bounds
+   */
+  peek(e = 0) {
+    const t = this._index + e;
+    return t >= this.textLen || t < 0 ? "" : this.text[t];
+  }
+  /**
+   * Find the next occurrence of a character
+   * @param char - The character to find
+   * @param escape - Whether to handle escaped characters
+   * @returns Index of the character, or -1 if not found
+   */
+  find(e, t = !1) {
+    let r = this._index;
+    for (; r < this.textLen; ) {
+      if (t && this.text[r] === "\\") {
+        if (r + 1 < this.textLen) {
+          if (this.text[r + 1] === e)
+            return r + 1;
+          r += 2;
+          continue;
+        }
+        r++;
+        continue;
+      }
+      if (this.text[r] === e)
+        return r;
+      r++;
+    }
+    return -1;
+  }
+  /**
+   * Get the remaining text from the current position
+   */
+  get tail() {
+    return this.text.slice(this._index);
+  }
+  /**
+   * Check if the next character is a space
+   */
+  isNextSpace() {
+    return this.peek() === " ";
+  }
+  /**
+   * Consume spaces until a non-space character is found
+   * @returns Number of spaces consumed
+   */
+  consumeSpaces() {
+    let e = 0;
+    for (; this.isNextSpace(); )
+      this.consume(), e++;
+    return e;
+  }
+}
+class d {
+  constructor() {
+    this._stroke = 0, this.continueStroke = !1, this._aci = 7, this.rgb = null, this.align = 0, this.fontFace = { family: "", style: "Regular", weight: 400 }, this.capHeight = 1, this.widthFactor = 1, this.charTrackingFactor = 1, this.oblique = 0, this.paragraph = {
+      indent: 0,
+      left: 0,
+      right: 0,
+      align: 0,
+      tab_stops: []
+    };
+  }
+  /**
+   * Get the ACI color value
+   */
+  get aci() {
+    return this._aci;
+  }
+  /**
+   * Set the ACI color value
+   * @param value - ACI color value (0-256)
+   * @throws Error if value is out of range
+   */
+  set aci(e) {
+    if (e >= 0 && e <= 256)
+      this._aci = e, this.rgb = null;
+    else
+      throw new Error("ACI not in range [0, 256]");
+  }
+  /**
+   * Get whether text is underlined
+   */
+  get underline() {
+    return !!(this._stroke & 1);
+  }
+  /**
+   * Set whether text is underlined
+   * @param value - Whether to underline
+   */
+  set underline(e) {
+    this._setStrokeState(1, e);
+  }
+  /**
+   * Get whether text has strike-through
+   */
+  get strikeThrough() {
+    return !!(this._stroke & 4);
+  }
+  /**
+   * Set whether text has strike-through
+   * @param value - Whether to strike through
+   */
+  set strikeThrough(e) {
+    this._setStrokeState(4, e);
+  }
+  /**
+   * Get whether text has overline
+   */
+  get overline() {
+    return !!(this._stroke & 2);
+  }
+  /**
+   * Set whether text has overline
+   * @param value - Whether to overline
+   */
+  set overline(e) {
+    this._setStrokeState(2, e);
+  }
+  /**
+   * Check if any stroke formatting is active
+   */
+  get hasAnyStroke() {
+    return !!this._stroke;
+  }
+  /**
+   * Set the state of a stroke type
+   * @param stroke - The stroke type to set
+   * @param state - Whether to enable or disable the stroke
+   */
+  _setStrokeState(e, t = !0) {
+    t ? this._stroke |= e : this._stroke &= ~e;
+  }
+  /**
+   * Create a copy of this context
+   * @returns A new context with the same properties
+   */
+  copy() {
+    const e = new d();
+    return e._stroke = this._stroke, e.continueStroke = this.continueStroke, e._aci = this._aci, e.rgb = this.rgb, e.align = this.align, e.fontFace = { ...this.fontFace }, e.capHeight = this.capHeight, e.widthFactor = this.widthFactor, e.charTrackingFactor = this.charTrackingFactor, e.oblique = this.oblique, e.paragraph = { ...this.paragraph }, e;
+  }
+}
+class f {
+  /**
+   * Create a new MText token
+   * @param type - The token type
+   * @param ctx - The text context at this token
+   * @param data - Optional token data
+   */
+  constructor(e, t, r) {
+    this.type = e, this.ctx = t, this.data = r;
+  }
+}
+export {
+  d as MTextContext,
+  g as MTextLineAlignment,
+  E as MTextParagraphAlignment,
+  N as MTextParser,
+  m as MTextStroke,
+  f as MTextToken,
+  p as TextScanner,
+  x as TokenType,
+  S as caretDecode,
+  F as escapeDxfLineEndings,
+  C as hasInlineFormattingCodes,
+  _ as int2rgb,
+  I as rgb2int
+};
+//# sourceMappingURL=parser.es.js.map