gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/render/canvas/LineStringBuilder.mjs

@@ -0,0 +1,122 @@
+import { defaultLineDash as p, defaultLineDashOffset as S } from "../canvas.mjs";
+import g from "./Builder.mjs";
+import l, { beginPathInstruction as c, strokeInstruction as h } from "./Instruction.mjs";
+class y extends g {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, i, e, s) {
+    super(t, i, e, s);
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @private
+   * @return {number} end.
+   */
+  drawFlatCoordinates_(t, i, e, s) {
+    const o = this.coordinates.length, r = this.appendFlatLineCoordinates(
+      t,
+      i,
+      e,
+      s,
+      !1,
+      !1
+    ), n = [
+      l.MOVE_TO_LINE_TO,
+      o,
+      r
+    ];
+    return this.instructions.push(n), this.hitDetectionInstructions.push(n), e;
+  }
+  /**
+   * @param {import("../../geom/LineString.js").default|import("../Feature.js").default} lineStringGeometry Line string geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {number} [index] Render order index.
+   * @override
+   */
+  drawLineString(t, i, e) {
+    const s = this.state, o = s.strokeStyle, r = s.lineWidth;
+    if (o === void 0 || r === void 0)
+      return;
+    this.updateStrokeStyle(s, this.applyStroke), this.beginGeometry(t, i, e), this.hitDetectionInstructions.push(
+      [
+        l.SET_STROKE_STYLE,
+        s.strokeStyle,
+        s.lineWidth,
+        s.lineCap,
+        s.lineJoin,
+        s.miterLimit,
+        p,
+        S
+      ],
+      c
+    );
+    const n = t.getFlatCoordinates(), a = t.getStride();
+    this.drawFlatCoordinates_(
+      n,
+      0,
+      n.length,
+      a
+    ), this.hitDetectionInstructions.push(h), this.endGeometry(i);
+  }
+  /**
+   * @param {import("../../geom/MultiLineString.js").default|import("../Feature.js").default} multiLineStringGeometry MultiLineString geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {number} [index] Render order index.
+   * @override
+   */
+  drawMultiLineString(t, i, e) {
+    const s = this.state, o = s.strokeStyle, r = s.lineWidth;
+    if (o === void 0 || r === void 0)
+      return;
+    this.updateStrokeStyle(s, this.applyStroke), this.beginGeometry(t, i, e), this.hitDetectionInstructions.push(
+      [
+        l.SET_STROKE_STYLE,
+        s.strokeStyle,
+        s.lineWidth,
+        s.lineCap,
+        s.lineJoin,
+        s.miterLimit,
+        p,
+        S
+      ],
+      c
+    );
+    const n = t.getEnds(), a = t.getFlatCoordinates(), f = t.getStride();
+    let u = 0;
+    for (let d = 0, k = n.length; d < k; ++d)
+      u = this.drawFlatCoordinates_(
+        a,
+        u,
+        /** @type {number} */
+        n[d],
+        f
+      );
+    this.hitDetectionInstructions.push(h), this.endGeometry(i);
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   * @override
+   */
+  finish() {
+    const t = this.state;
+    return t.lastStroke != null && t.lastStroke != this.coordinates.length && this.instructions.push(h), this.reverseHitDetectionInstructions(), this.state = null, super.finish();
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @override
+   */
+  applyStroke(t) {
+    t.lastStroke != null && t.lastStroke != this.coordinates.length && (this.instructions.push(h), t.lastStroke = this.coordinates.length), t.lastStroke = 0, super.applyStroke(t), this.instructions.push(c);
+  }
+}
+const T = y;
+export {
+  T as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/render/canvas/PolygonBuilder.mjs

@@ -0,0 +1,169 @@
+import { snap as _ } from "../../geom/flat/simplify.mjs";
+import { defaultFillStyle as y, defaultLineDash as I, defaultLineDashOffset as k } from "../canvas.mjs";
+import C from "./Builder.mjs";
+import h, { beginPathInstruction as a, closePathInstruction as L, fillInstruction as f, strokeInstruction as S } from "./Instruction.mjs";
+class T extends C {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(i, s, e, t) {
+    super(i, s, e, t);
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {Array<number>} ends Ends.
+   * @param {number} stride Stride.
+   * @private
+   * @return {number} End.
+   */
+  drawFlatCoordinatess_(i, s, e, t) {
+    const l = this.state, c = l.fillStyle !== void 0, n = l.strokeStyle !== void 0, d = e.length;
+    this.instructions.push(a), this.hitDetectionInstructions.push(a);
+    for (let o = 0; o < d; ++o) {
+      const r = e[o], u = this.coordinates.length, p = this.appendFlatLineCoordinates(
+        i,
+        s,
+        r,
+        t,
+        !0,
+        !n
+      ), E = [
+        h.MOVE_TO_LINE_TO,
+        u,
+        p
+      ];
+      this.instructions.push(E), this.hitDetectionInstructions.push(E), n && (this.instructions.push(L), this.hitDetectionInstructions.push(L)), s = r;
+    }
+    return c && (this.instructions.push(f), this.hitDetectionInstructions.push(f)), n && (this.instructions.push(S), this.hitDetectionInstructions.push(S)), s;
+  }
+  /**
+   * @param {import("../../geom/Circle.js").default} circleGeometry Circle geometry.
+   * @param {import("../../Feature.js").default} feature Feature.
+   * @param {number} [index] Render order index.
+   * @override
+   */
+  drawCircle(i, s, e) {
+    const t = this.state, l = t.fillStyle, c = t.strokeStyle;
+    if (l === void 0 && c === void 0)
+      return;
+    this.setFillStrokeStyles_(), this.beginGeometry(i, s, e), t.fillStyle !== void 0 && this.hitDetectionInstructions.push([
+      h.SET_FILL_STYLE,
+      y
+    ]), t.strokeStyle !== void 0 && this.hitDetectionInstructions.push([
+      h.SET_STROKE_STYLE,
+      t.strokeStyle,
+      t.lineWidth,
+      t.lineCap,
+      t.lineJoin,
+      t.miterLimit,
+      I,
+      k
+    ]);
+    const n = i.getFlatCoordinates(), d = i.getStride(), o = this.coordinates.length;
+    this.appendFlatLineCoordinates(
+      n,
+      0,
+      n.length,
+      d,
+      !1,
+      !1
+    );
+    const r = [h.CIRCLE, o];
+    this.instructions.push(a, r), this.hitDetectionInstructions.push(a, r), t.fillStyle !== void 0 && (this.instructions.push(f), this.hitDetectionInstructions.push(f)), t.strokeStyle !== void 0 && (this.instructions.push(S), this.hitDetectionInstructions.push(S)), this.endGeometry(s);
+  }
+  /**
+   * @param {import("../../geom/Polygon.js").default|import("../Feature.js").default} polygonGeometry Polygon geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {number} [index] Render order index.
+   * @override
+   */
+  drawPolygon(i, s, e) {
+    const t = this.state, l = t.fillStyle, c = t.strokeStyle;
+    if (l === void 0 && c === void 0)
+      return;
+    this.setFillStrokeStyles_(), this.beginGeometry(i, s, e), t.fillStyle !== void 0 && this.hitDetectionInstructions.push([
+      h.SET_FILL_STYLE,
+      y
+    ]), t.strokeStyle !== void 0 && this.hitDetectionInstructions.push([
+      h.SET_STROKE_STYLE,
+      t.strokeStyle,
+      t.lineWidth,
+      t.lineCap,
+      t.lineJoin,
+      t.miterLimit,
+      I,
+      k
+    ]);
+    const n = i.getEnds(), d = i.getOrientedFlatCoordinates(), o = i.getStride();
+    this.drawFlatCoordinatess_(
+      d,
+      0,
+      /** @type {Array<number>} */
+      n,
+      o
+    ), this.endGeometry(s);
+  }
+  /**
+   * @param {import("../../geom/MultiPolygon.js").default} multiPolygonGeometry MultiPolygon geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {number} [index] Render order index.
+   * @override
+   */
+  drawMultiPolygon(i, s, e) {
+    const t = this.state, l = t.fillStyle, c = t.strokeStyle;
+    if (l === void 0 && c === void 0)
+      return;
+    this.setFillStrokeStyles_(), this.beginGeometry(i, s, e), t.fillStyle !== void 0 && this.hitDetectionInstructions.push([
+      h.SET_FILL_STYLE,
+      y
+    ]), t.strokeStyle !== void 0 && this.hitDetectionInstructions.push([
+      h.SET_STROKE_STYLE,
+      t.strokeStyle,
+      t.lineWidth,
+      t.lineCap,
+      t.lineJoin,
+      t.miterLimit,
+      I,
+      k
+    ]);
+    const n = i.getEndss(), d = i.getOrientedFlatCoordinates(), o = i.getStride();
+    let r = 0;
+    for (let u = 0, p = n.length; u < p; ++u)
+      r = this.drawFlatCoordinatess_(
+        d,
+        r,
+        n[u],
+        o
+      );
+    this.endGeometry(s);
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   * @override
+   */
+  finish() {
+    this.reverseHitDetectionInstructions(), this.state = null;
+    const i = this.tolerance;
+    if (i !== 0) {
+      const s = this.coordinates;
+      for (let e = 0, t = s.length; e < t; ++e)
+        s[e] = _(s[e], i);
+    }
+    return super.finish();
+  }
+  /**
+   * @private
+   */
+  setFillStrokeStyles_() {
+    const i = this.state;
+    this.updateFillStyle(i, this.createFill), this.updateStrokeStyle(i, this.applyStroke);
+  }
+}
+const w = T;
+export {
+  w as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/render/canvas/TextBuilder.mjs

@@ -0,0 +1,335 @@
+import { asColorLike as R } from "../../colorlike.mjs";
+import { intersects as M } from "../../extent.mjs";
+import { lineChunk as O } from "../../geom/flat/linechunk.mjs";
+import { matchingChunk as T } from "../../geom/flat/straightchunk.mjs";
+import { getUid as b } from "../../util.mjs";
+import { defaultFillStyle as L, defaultPadding as W, defaultTextAlign as w, defaultTextBaseline as D, defaultLineCap as N, defaultLineDash as P, defaultLineDashOffset as B, defaultLineJoin as v, defaultLineWidth as I, defaultMiterLimit as E, defaultStrokeStyle as Y, defaultFont as G, registerFont as J } from "../canvas.mjs";
+import U from "./Builder.mjs";
+import A from "./Instruction.mjs";
+const X = {
+  left: 0,
+  center: 0.5,
+  right: 1,
+  top: 0,
+  middle: 0.5,
+  hanging: 0.2,
+  alphabetic: 0.8,
+  ideographic: 0.8,
+  bottom: 1
+};
+class et extends U {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, h, i, n) {
+    super(t, h, i, n), this.labels_ = null, this.text_ = "", this.textOffsetX_ = 0, this.textOffsetY_ = 0, this.textRotateWithView_ = void 0, this.textKeepUpright_ = void 0, this.textRotation_ = 0, this.textFillState_ = null, this.fillStates = {}, this.fillStates[L] = { fillStyle: L }, this.textStrokeState_ = null, this.strokeStates = {}, this.textState_ = /** @type {import("../canvas.js").TextState} */
+    {}, this.textStates = {}, this.textKey_ = "", this.fillKey_ = "", this.strokeKey_ = "", this.declutterMode_ = void 0, this.declutterImageWithText_ = void 0;
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   * @override
+   */
+  finish() {
+    const t = super.finish();
+    return t.textStates = this.textStates, t.fillStates = this.fillStates, t.strokeStates = this.strokeStates, t;
+  }
+  /**
+   * @param {import("../../geom/SimpleGeometry.js").default|import("../Feature.js").default} geometry Geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {number} [index] Render order index.
+   * @override
+   */
+  drawText(t, h, i) {
+    const n = this.textFillState_, e = this.textStrokeState_, s = this.textState_;
+    if (this.text_ === "" || !s || !n && !e)
+      return;
+    const a = this.coordinates;
+    let r = a.length;
+    const g = t.getType();
+    let l = null, u = t.getStride();
+    if (s.placement === "line" && (g == "LineString" || g == "MultiLineString" || g == "Polygon" || g == "MultiPolygon")) {
+      if (!M(this.maxExtent, t.getExtent()))
+        return;
+      let o;
+      if (l = t.getFlatCoordinates(), g == "LineString")
+        o = [l.length];
+      else if (g == "MultiLineString")
+        o = /** @type {import("../../geom/MultiLineString.js").default} */
+        t.getEnds();
+      else if (g == "Polygon")
+        o = /** @type {import("../../geom/Polygon.js").default} */
+        t.getEnds().slice(0, 1);
+      else if (g == "MultiPolygon") {
+        const f = (
+          /** @type {import("../../geom/MultiPolygon.js").default} */
+          t.getEndss()
+        );
+        o = [];
+        for (let p = 0, _ = f.length; p < _; ++p)
+          o.push(f[p][0]);
+      }
+      this.beginGeometry(t, h, i);
+      const S = s.repeat, y = S ? void 0 : s.textAlign;
+      let k = 0;
+      for (let f = 0, p = o.length; f < p; ++f) {
+        let _;
+        S ? _ = O(
+          S * this.resolution,
+          l,
+          k,
+          o[f],
+          u
+        ) : _ = [l.slice(k, o[f])];
+        for (let K = 0, c = _.length; K < c; ++K) {
+          const d = _[K];
+          let x = 0, m = d.length;
+          if (y == null) {
+            const F = T(
+              s.maxAngle,
+              d,
+              0,
+              d.length,
+              2
+            );
+            x = F[0], m = F[1];
+          }
+          for (let F = x; F < m; F += u)
+            a.push(d[F], d[F + 1]);
+          const C = a.length;
+          k = o[f], this.drawChars_(r, C), r = C;
+        }
+      }
+      this.endGeometry(h);
+    } else {
+      let o = s.overflow ? null : [];
+      switch (g) {
+        case "Point":
+        case "MultiPoint":
+          l = /** @type {import("../../geom/MultiPoint.js").default} */
+          t.getFlatCoordinates();
+          break;
+        case "LineString":
+          l = /** @type {import("../../geom/LineString.js").default} */
+          t.getFlatMidpoint();
+          break;
+        case "Circle":
+          l = /** @type {import("../../geom/Circle.js").default} */
+          t.getCenter();
+          break;
+        case "MultiLineString":
+          l = /** @type {import("../../geom/MultiLineString.js").default} */
+          t.getFlatMidpoints(), u = 2;
+          break;
+        case "Polygon":
+          l = /** @type {import("../../geom/Polygon.js").default} */
+          t.getFlatInteriorPoint(), s.overflow || o.push(l[2] / this.resolution), u = 3;
+          break;
+        case "MultiPolygon":
+          const c = (
+            /** @type {import("../../geom/MultiPolygon.js").default} */
+            t.getFlatInteriorPoints()
+          );
+          l = [];
+          for (let d = 0, x = c.length; d < x; d += 3)
+            s.overflow || o.push(c[d + 2] / this.resolution), l.push(c[d], c[d + 1]);
+          if (l.length === 0)
+            return;
+          u = 2;
+          break;
+      }
+      const S = this.appendFlatPointCoordinates(l, u);
+      if (S === r)
+        return;
+      if (o && (S - r) / 2 !== l.length / u) {
+        let c = r / 2;
+        o = o.filter((d, x) => {
+          const m = a[(c + x) * 2] === l[x * u] && a[(c + x) * 2 + 1] === l[x * u + 1];
+          return m || --c, m;
+        });
+      }
+      this.saveTextStates_();
+      const y = s.backgroundFill ? this.createFill(this.fillStyleToState(s.backgroundFill)) : null, k = s.backgroundStroke ? this.createStroke(this.strokeStyleToState(s.backgroundStroke)) : null;
+      this.beginGeometry(t, h, i);
+      let f = s.padding;
+      if (f != W && (s.scale[0] < 0 || s.scale[1] < 0)) {
+        let c = s.padding[0], d = s.padding[1], x = s.padding[2], m = s.padding[3];
+        s.scale[0] < 0 && (d = -d, m = -m), s.scale[1] < 0 && (c = -c, x = -x), f = [c, d, x, m];
+      }
+      const p = this.pixelRatio;
+      this.instructions.push([
+        A.DRAW_IMAGE,
+        r,
+        S,
+        null,
+        NaN,
+        NaN,
+        NaN,
+        1,
+        0,
+        0,
+        this.textRotateWithView_,
+        this.textRotation_,
+        [1, 1],
+        NaN,
+        this.declutterMode_,
+        this.declutterImageWithText_,
+        f == W ? W : f.map(function(c) {
+          return c * p;
+        }),
+        y,
+        k,
+        this.text_,
+        this.textKey_,
+        this.strokeKey_,
+        this.fillKey_,
+        this.textOffsetX_,
+        this.textOffsetY_,
+        o
+      ]);
+      const _ = 1 / p, K = y ? y.slice(0) : null;
+      K && (K[1] = L), this.hitDetectionInstructions.push([
+        A.DRAW_IMAGE,
+        r,
+        S,
+        null,
+        NaN,
+        NaN,
+        NaN,
+        1,
+        0,
+        0,
+        this.textRotateWithView_,
+        this.textRotation_,
+        [_, _],
+        NaN,
+        this.declutterMode_,
+        this.declutterImageWithText_,
+        f,
+        K,
+        k,
+        this.text_,
+        this.textKey_,
+        this.strokeKey_,
+        this.fillKey_ ? L : this.fillKey_,
+        this.textOffsetX_,
+        this.textOffsetY_,
+        o
+      ]), this.endGeometry(h);
+    }
+  }
+  /**
+   * @private
+   */
+  saveTextStates_() {
+    const t = this.textStrokeState_, h = this.textState_, i = this.textFillState_, n = this.strokeKey_;
+    t && (n in this.strokeStates || (this.strokeStates[n] = {
+      strokeStyle: t.strokeStyle,
+      lineCap: t.lineCap,
+      lineDashOffset: t.lineDashOffset,
+      lineWidth: t.lineWidth,
+      lineJoin: t.lineJoin,
+      miterLimit: t.miterLimit,
+      lineDash: t.lineDash
+    }));
+    const e = this.textKey_;
+    e in this.textStates || (this.textStates[e] = {
+      font: h.font,
+      textAlign: h.textAlign || w,
+      justify: h.justify,
+      textBaseline: h.textBaseline || D,
+      scale: h.scale
+    });
+    const s = this.fillKey_;
+    i && (s in this.fillStates || (this.fillStates[s] = {
+      fillStyle: i.fillStyle
+    }));
+  }
+  /**
+   * @private
+   * @param {number} begin Begin.
+   * @param {number} end End.
+   */
+  drawChars_(t, h) {
+    const i = this.textStrokeState_, n = this.textState_, e = this.strokeKey_, s = this.textKey_, a = this.fillKey_;
+    this.saveTextStates_();
+    const r = this.pixelRatio, g = X[n.textBaseline], l = this.textOffsetY_ * r, u = this.text_, o = i ? i.lineWidth * Math.abs(n.scale[0]) / 2 : 0;
+    this.instructions.push([
+      A.DRAW_CHARS,
+      t,
+      h,
+      g,
+      n.overflow,
+      a,
+      n.maxAngle,
+      r,
+      l,
+      e,
+      o * r,
+      u,
+      s,
+      1,
+      this.declutterMode_,
+      this.textKeepUpright_
+    ]), this.hitDetectionInstructions.push([
+      A.DRAW_CHARS,
+      t,
+      h,
+      g,
+      n.overflow,
+      a && L,
+      n.maxAngle,
+      r,
+      l,
+      e,
+      o * r,
+      u,
+      s,
+      1 / r,
+      this.declutterMode_,
+      this.textKeepUpright_
+    ]);
+  }
+  /**
+   * @param {import("../../style/Text.js").default} textStyle Text style.
+   * @param {Object} [sharedData] Shared data.
+   * @override
+   */
+  setTextStyle(t, h) {
+    let i, n, e;
+    if (!t)
+      this.text_ = "";
+    else {
+      const s = t.getFill();
+      s ? (n = this.textFillState_, n || (n = /** @type {import("../canvas.js").FillState} */
+      {}, this.textFillState_ = n), n.fillStyle = R(
+        s.getColor() || L
+      )) : (n = null, this.textFillState_ = n);
+      const a = t.getStroke();
+      if (!a)
+        e = null, this.textStrokeState_ = e;
+      else {
+        e = this.textStrokeState_, e || (e = /** @type {import("../canvas.js").StrokeState} */
+        {}, this.textStrokeState_ = e);
+        const k = a.getLineDash(), f = a.getLineDashOffset(), p = a.getWidth(), _ = a.getMiterLimit();
+        e.lineCap = a.getLineCap() || N, e.lineDash = k ? k.slice() : P, e.lineDashOffset = f === void 0 ? B : f, e.lineJoin = a.getLineJoin() || v, e.lineWidth = p === void 0 ? I : p, e.miterLimit = _ === void 0 ? E : _, e.strokeStyle = R(
+          a.getColor() || Y
+        );
+      }
+      i = this.textState_;
+      const r = t.getFont() || G;
+      J(r);
+      const g = t.getScaleArray();
+      i.overflow = t.getOverflow(), i.font = r, i.maxAngle = t.getMaxAngle(), i.placement = t.getPlacement(), i.textAlign = t.getTextAlign(), i.repeat = t.getRepeat(), i.justify = t.getJustify(), i.textBaseline = t.getTextBaseline() || D, i.backgroundFill = t.getBackgroundFill(), i.backgroundStroke = t.getBackgroundStroke(), i.padding = t.getPadding() || W, i.scale = g === void 0 ? [1, 1] : g;
+      const l = t.getOffsetX(), u = t.getOffsetY(), o = t.getRotateWithView(), S = t.getKeepUpright(), y = t.getRotation();
+      this.text_ = t.getText() || "", this.textOffsetX_ = l === void 0 ? 0 : l, this.textOffsetY_ = u === void 0 ? 0 : u, this.textRotateWithView_ = o === void 0 ? !1 : o, this.textKeepUpright_ = S === void 0 ? !0 : S, this.textRotation_ = y === void 0 ? 0 : y, this.strokeKey_ = e ? (typeof e.strokeStyle == "string" ? e.strokeStyle : b(e.strokeStyle)) + e.lineCap + e.lineDashOffset + "|" + e.lineWidth + e.lineJoin + e.miterLimit + "[" + e.lineDash.join() + "]" : "", this.textKey_ = i.font + i.scale + (i.textAlign || "?") + (i.repeat || "?") + (i.justify || "?") + (i.textBaseline || "?"), this.fillKey_ = n && n.fillStyle ? typeof n.fillStyle == "string" ? n.fillStyle : "|" + b(n.fillStyle) : "";
+    }
+    this.declutterMode_ = t.getDeclutterMode(), this.declutterImageWithText_ = h;
+  }
+}
+export {
+  X as TEXT_ALIGN,
+  et as default
+};