@mlightcad/mtext-parser 1.0.0 → 1.0.3

package/dist/parser.es.js

@@ -0,0 +1,727 @@
+var k = /* @__PURE__ */ ((r) => (r[r.NONE = 0] = "NONE", r[r.WORD = 1] = "WORD", r[r.STACK = 2] = "STACK", r[r.SPACE = 3] = "SPACE", r[r.NBSP = 4] = "NBSP", r[r.TABULATOR = 5] = "TABULATOR", r[r.NEW_PARAGRAPH = 6] = "NEW_PARAGRAPH", r[r.NEW_COLUMN = 7] = "NEW_COLUMN", r[r.WRAP_AT_DIMLINE = 8] = "WRAP_AT_DIMLINE", r[r.PROPERTIES_CHANGED = 9] = "PROPERTIES_CHANGED", r))(k || {}), b = /* @__PURE__ */ ((r) => (r[r.BOTTOM = 0] = "BOTTOM", r[r.MIDDLE = 1] = "MIDDLE", r[r.TOP = 2] = "TOP", r))(b || {}), E = /* @__PURE__ */ ((r) => (r[r.DEFAULT = 0] = "DEFAULT", r[r.LEFT = 1] = "LEFT", r[r.RIGHT = 2] = "RIGHT", r[r.CENTER = 3] = "CENTER", r[r.JUSTIFIED = 4] = "JUSTIFIED", r[r.DISTRIBUTED = 5] = "DISTRIBUTED", r))(E || {}), m = /* @__PURE__ */ ((r) => (r[r.NONE = 0] = "NONE", r[r.UNDERLINE = 1] = "UNDERLINE", r[r.OVERLINE = 2] = "OVERLINE", r[r.STRIKE_THROUGH = 4] = "STRIKE_THROUGH", r))(m || {});
+const F = {
+  c: "Ø",
+  d: "°",
+  p: "±"
+}, S = {
+  l: 1,
+  r: 2,
+  c: 3,
+  j: 4,
+  d: 5
+  /* DISTRIBUTED */
+};
+function N(r) {
+  const [e, t, s] = r;
+  return s << 16 | t << 8 | e;
+}
+function _(r) {
+  const e = r & 255, t = r >> 8 & 255, s = r >> 16 & 255;
+  return [e, t, s];
+}
+function I(r) {
+  return r.replace(/\^(.)/g, (e, t) => {
+    const s = t.charCodeAt(0);
+    return s === 32 ? "^" : s === 73 ? "	" : s === 74 ? `
+` : s === 77 ? "" : "▯";
+  });
+}
+function O(r) {
+  return r.replace(/\r\n|\r|\n/g, "\\P");
+}
+function R(r) {
+  return r.replace(/\\P/g, "").replace(/\\~/g, "").includes("\\");
+}
+class D {
+  /**
+   * 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, s = !1) {
+    this.ctxStack = [], this.continueStroke = !1, this.scanner = new p(I(e)), this.ctx = t ?? new f(), this.lastCtx = this.ctx.copy(), this.yieldPropertyCommands = s, 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 = "", s = "", n = "";
+    const i = () => {
+      let a = e.peek(), h = !1;
+      return a.charCodeAt(0) < 32 && (a = " "), a === "\\" && (h = !0, e.consume(1), a = e.peek()), e.consume(1), [a, h];
+    }, c = () => {
+      let a = "";
+      for (; e.hasData; ) {
+        const [h, o] = i();
+        if (!o && "^/#".includes(h))
+          return [a, h];
+        a += h;
+      }
+      return [a, ""];
+    }, l = () => {
+      let a = "";
+      for (; e.hasData; ) {
+        const [h, o] = i();
+        o && h === ";" ? a += ";" : a += h;
+      }
+      return a;
+    };
+    return [t, n] = c(), n && (s = l()), [2, [t, s, n]];
+  }
+  /**
+   * Parse MText properties
+   * @param cmd - The property command to parse
+   * @returns Property changes if yieldPropertyCommands is true and changes occurred
+   */
+  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}`);
+    }
+    if (t.continueStroke = this.continueStroke, this.ctx = t, this.yieldPropertyCommands) {
+      const s = this.getPropertyChanges(this.lastCtx, t);
+      if (Object.keys(s).length > 0)
+        return this.lastCtx = this.ctx.copy(), {
+          command: e,
+          changes: s
+        };
+    }
+  }
+  /**
+   * Get property changes between two contexts
+   * @param oldCtx - The old context
+   * @param newCtx - The new context
+   * @returns Object containing changed properties
+   */
+  getPropertyChanges(e, t) {
+    const s = {};
+    if (e.underline !== t.underline && (s.underline = t.underline), e.overline !== t.overline && (s.overline = t.overline), e.strikeThrough !== t.strikeThrough && (s.strikeThrough = t.strikeThrough), e.aci !== t.aci && (s.aci = t.aci, s.rgb = t.rgb), e.rgb !== t.rgb && (s.rgb = t.rgb), e.align !== t.align && (s.align = t.align), JSON.stringify(e.fontFace) !== JSON.stringify(t.fontFace) && (s.fontFace = t.fontFace), e.capHeight !== t.capHeight && (s.capHeight = t.capHeight), e.widthFactor !== t.widthFactor && (s.widthFactor = t.widthFactor), e.charTrackingFactor !== t.charTrackingFactor && (s.charTrackingFactor = t.charTrackingFactor), e.oblique !== t.oblique && (s.oblique = t.oblique), JSON.stringify(e.paragraph) !== JSON.stringify(t.paragraph)) {
+      const n = {};
+      e.paragraph.indent !== t.paragraph.indent && (n.indent = t.paragraph.indent), e.paragraph.align !== t.paragraph.align && (n.align = t.paragraph.align), e.paragraph.left !== t.paragraph.left && (n.left = t.paragraph.left), e.paragraph.right !== t.paragraph.right && (n.right = t.paragraph.right), JSON.stringify(e.paragraph.tab_stops) !== JSON.stringify(t.paragraph.tab_stops) && (n.tab_stops = t.paragraph.tab_stops), Object.keys(n).length > 0 && (s.paragraph = n);
+    }
+    return s;
+  }
+  /**
+   * 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 s = parseFloat(t.slice(0, -1));
+        e *= Math.abs(s);
+      } 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 s = parseInt(t);
+      s < 257 && (e.aci = s, e.rgb = null);
+    }
+    this.consumeOptionalTerminator();
+  }
+  /**
+   * Parse RGB color property
+   * @param ctx - The context to update
+   */
+  parseRgbColor(e) {
+    const t = this.extractIntExpression();
+    if (t) {
+      const s = parseInt(t) & 16777215, [n, i, c] = _(s);
+      e.rgb = [c, i, n];
+    }
+    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+)?/, s = this.scanner.tail.match(t);
+    if (s) {
+      const n = s[0];
+      return this.scanner.consume(n.length), n;
+    }
+    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 n = this.scanner.peek(t - this.scanner.currentIndex - 1) === "\\", i = this.scanner.tail.slice(0, t - this.scanner.currentIndex + (n ? 1 : 0));
+    return this.scanner.consume(i.length + 1), i;
+  }
+  /**
+   * Parse font properties
+   * @param ctx - The context to update
+   */
+  parseFontProperties(e) {
+    const t = this.extractExpression().split("|");
+    if (t.length > 0 && t[0]) {
+      const s = t[0];
+      let n = "Regular", i = 400;
+      for (const c of t.slice(1))
+        c.startsWith("b1") ? i = 700 : c.startsWith("i1") && (n = "Italic");
+      e.fontFace = {
+        family: s,
+        style: n,
+        weight: i
+      };
+    }
+  }
+  /**
+   * 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 s = e.paragraph.indent, n = e.paragraph.left, i = e.paragraph.right, c = e.paragraph.align, l = [];
+    const a = () => {
+      const h = t.tail.match(/^[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?/);
+      if (h) {
+        const o = parseFloat(h[0]);
+        for (t.consume(h[0].length); t.peek() === ","; )
+          t.consume(1);
+        return o;
+      }
+      return 0;
+    };
+    for (; t.hasData; )
+      switch (t.get()) {
+        case "i":
+          s = a();
+          break;
+        case "l":
+          n = a();
+          break;
+        case "r":
+          i = a();
+          break;
+        case "x":
+          break;
+        case "q": {
+          const o = t.get();
+          for (c = S[o] || 0; t.peek() === ","; )
+            t.consume(1);
+          break;
+        }
+        case "t":
+          for (l = []; t.hasData; ) {
+            const o = t.peek();
+            if (o === "r" || o === "c") {
+              t.consume(1);
+              const u = a();
+              l.push(o + u.toString());
+            } else {
+              const u = a();
+              isNaN(u) ? t.consume(1) : l.push(u);
+            }
+          }
+          break;
+      }
+    e.paragraph = {
+      indent: s,
+      left: n,
+      right: i,
+      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 s = null;
+    const n = () => {
+      var c;
+      let i = "";
+      for (; this.scanner.hasData; ) {
+        let l = !1, a = this.scanner.peek();
+        const h = this.scanner.currentIndex;
+        if (a.charCodeAt(0) < 32) {
+          if (this.scanner.consume(1), a === "	")
+            return [5, null];
+          if (a === `
+`)
+            return [6, null];
+          a = " ";
+        }
+        if (a === "\\")
+          if ("\\{}".includes(this.scanner.peek(1)))
+            l = !0, this.scanner.consume(1), a = this.scanner.peek();
+          else {
+            if (i)
+              return [1, i];
+            this.scanner.consume(1);
+            const o = this.scanner.get();
+            switch (o) {
+              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 d = this.decodeMultiByteChar(u);
+                    return i ? [1, i] : [1, d];
+                  }
+                  this.scanner.consume(-1);
+                }
+                i += "\\M";
+                continue;
+              default:
+                if (o)
+                  try {
+                    const u = this.parseProperties(o);
+                    if (this.yieldPropertyCommands && u)
+                      return this.lastCtx = this.ctx.copy(), [9, u];
+                    continue;
+                  } catch {
+                    const u = this.scanner.tail.slice(
+                      h,
+                      this.scanner.currentIndex
+                    );
+                    i += u;
+                  }
+            }
+            continue;
+          }
+        if (a === "%" && this.scanner.peek(1) === "%") {
+          const o = this.scanner.peek(2).toLowerCase(), u = F[o];
+          if (u) {
+            this.scanner.consume(3), i += u;
+            continue;
+          } else {
+            this.scanner.consume(3);
+            continue;
+          }
+        }
+        if (a === " ")
+          return i ? (this.scanner.consume(1), s = 3, [1, i]) : (this.scanner.consume(1), [3, null]);
+        if (!l) {
+          if (a === "{") {
+            if (i)
+              return [1, i];
+            this.scanner.consume(1), this.pushCtx();
+            continue;
+          } else if (a === "}") {
+            if (i)
+              return [1, i];
+            this.scanner.consume(1), this.popCtx();
+            continue;
+          }
+        }
+        this.scanner.consume(1), a.charCodeAt(0) >= 32 && (i += a);
+      }
+      return i ? [1, i] : [0, null];
+    };
+    for (; ; ) {
+      const [i, c] = n();
+      if (i)
+        yield new g(i, this.ctx, c), s && (yield new g(s, this.ctx, null), s = 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 s = this._index;
+    for (; s < this.textLen; ) {
+      if (t && this.text[s] === "\\") {
+        if (s + 1 < this.textLen) {
+          if (this.text[s + 1] === e)
+            return s + 1;
+          s += 2;
+          continue;
+        }
+        s++;
+        continue;
+      }
+      if (this.text[s] === e)
+        return s;
+      s++;
+    }
+    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 f {
+  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 f();
+    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 g {
+  /**
+   * 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, s) {
+    this.type = e, this.ctx = t, this.data = s;
+  }
+}
+export {
+  f as MTextContext,
+  b as MTextLineAlignment,
+  E as MTextParagraphAlignment,
+  D as MTextParser,
+  m as MTextStroke,
+  g as MTextToken,
+  p as TextScanner,
+  k as TokenType,
+  I as caretDecode,
+  O as escapeDxfLineEndings,
+  R as hasInlineFormattingCodes,
+  _ as int2rgb,
+  N as rgb2int
+};
+//# sourceMappingURL=parser.es.js.map