text: "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  const SPACES_RE = /^[ \t]+$/;
  
  class Buffer {
    constructor(map) {
      this._map = null;
      this._buf = [];
      this._last = "";
      this._queue = [];
      this._position = {
        line: 1,
        column: 0
      };
      this._sourcePosition = {
        identifierName: null,
        line: null,
        column: null,
        filename: null
      };
      this._disallowedPop = null;
      this._map = map;
    }
  
    get() {
      this._flush();
  
      const map = this._map;
      const result = {
        code: this._buf.join("").trimRight(),
        map: null,
        rawMappings: map == null ? void 0 : map.getRawMappings()
      };
  
      if (map) {
        Object.defineProperty(result, "map", {
          configurable: true,
          enumerable: true,
  
          get() {
            return this.map = map.get();
          },
  
          set(value) {
            Object.defineProperty(this, "map", {
              value,
              writable: true
            });
          }
  
        });
      }
  
      return result;
    }
  
    append(str) {
      this._flush();
  
      const {
        line,
        column,
        filename,
        identifierName,
        force
      } = this._sourcePosition;
  
      this._append(str, line, column, identifierName, filename, force);
    }
  
    queue(str) {
      if (str === "\n") {
        while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) {
          this._queue.shift();
        }
      }
  
      const {
        line,
        column,
        filename,
        identifierName,
        force
      } = this._sourcePosition;
  
      this._queue.unshift([str, line, column, identifierName, filename, force]);
    }
  
    _flush() {
      let item;
  
      while (item = this._queue.pop()) this._append(...item);
    }
  
    _append(str, line, column, identifierName, filename, force) {
      this._buf.push(str);
  
      this._last = str[str.length - 1];
      let i = str.indexOf("\n");
      let last = 0;
  
      if (i !== 0) {
        this._mark(line, column, identifierName, filename, force);
      }
  
      while (i !== -1) {
        this._position.line++;
        this._position.column = 0;
        last = i + 1;
  
        if (last < str.length) {
          this._mark(++line, 0, identifierName, filename, force);
        }
  
        i = str.indexOf("\n", last);
      }
  
      this._position.column += str.length - last;
    }
  
    _mark(line, column, identifierName, filename, force) {
      var _this$_map;
  
      (_this$_map = this._map) == null ? void 0 : _this$_map.mark(this._position.line, this._position.column, line, column, identifierName, filename, force);
    }
  
    removeTrailingNewline() {
      if (this._queue.length > 0 && this._queue[0][0] === "\n") {
        this._queue.shift();
      }
    }
  
    removeLastSemicolon() {
      if (this._queue.length > 0 && this._queue[0][0] === ";") {
        this._queue.shift();
      }
    }
  
    endsWith(suffix) {
      if (suffix.length === 1) {
        let last;
  
        if (this._queue.length > 0) {
          const str = this._queue[0][0];
          last = str[str.length - 1];
        } else {
          last = this._last;
        }
  
        return last === suffix;
      }
  
      const end = this._last + this._queue.reduce((acc, item) => item[0] + acc, "");
  
      if (suffix.length <= end.length) {
        return end.slice(-suffix.length) === suffix;
      }
  
      return false;
    }
  
    hasContent() {
      return this._queue.length > 0 || !!this._last;
    }
  
    exactSource(loc, cb) {
      this.source("start", loc, true);
      cb();
      this.source("end", loc);
  
      this._disallowPop("start", loc);
    }
  
    source(prop, loc, force) {
      if (prop && !loc) return;
  
      this._normalizePosition(prop, loc, this._sourcePosition, force);
    }
  
    withSource(prop, loc, cb) {
      if (!this._map) return cb();
      const originalLine = this._sourcePosition.line;
      const originalColumn = this._sourcePosition.column;
      const originalFilename = this._sourcePosition.filename;
      const originalIdentifierName = this._sourcePosition.identifierName;
      this.source(prop, loc);
      cb();
  
      if ((!this._sourcePosition.force || this._sourcePosition.line !== originalLine || this._sourcePosition.column !== originalColumn || this._sourcePosition.filename !== originalFilename) && (!this._disallowedPop || this._disallowedPop.line !== originalLine || this._disallowedPop.column !== originalColumn || this._disallowedPop.filename !== originalFilename)) {
        this._sourcePosition.line = originalLine;
        this._sourcePosition.column = originalColumn;
        this._sourcePosition.filename = originalFilename;
        this._sourcePosition.identifierName = originalIdentifierName;
        this._sourcePosition.force = false;
        this._disallowedPop = null;
      }
    }
  
    _disallowPop(prop, loc) {
      if (prop && !loc) return;
      this._disallowedPop = this._normalizePosition(prop, loc);
    }
  
    _normalizePosition(prop, loc, targetObj, force) {
      const pos = loc ? loc[prop] : null;
  
      if (targetObj === undefined) {
        targetObj = {
          identifierName: null,
          line: null,
          column: null,
          filename: null,
          force: false
        };
      }
  
      const origLine = targetObj.line;
      const origColumn = targetObj.column;
      const origFilename = targetObj.filename;
      targetObj.identifierName = prop === "start" && (loc == null ? void 0 : loc.identifierName) || null;
      targetObj.line = pos == null ? void 0 : pos.line;
      targetObj.column = pos == null ? void 0 : pos.column;
      targetObj.filename = loc == null ? void 0 : loc.filename;
  
      if (force || targetObj.line !== origLine || targetObj.column !== origColumn || targetObj.filename !== origFilename) {
        targetObj.force = force;
      }
  
      return targetObj;
    }
  
    getCurrentColumn() {
      const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
  
      const lastIndex = extra.lastIndexOf("\n");
      return lastIndex === -1 ? this._position.column + extra.length : extra.length - 1 - lastIndex;
    }
  
    getCurrentLine() {
      const extra = this._queue.reduce((acc, item) => item[0] + acc, "");
  
      let count = 0;
  
      for (let i = 0; i < extra.length; i++) {
        if (extra[i] === "\n") count++;
      }
  
      return this._position.line + count;
    }
  
  }
  
  exports.default = Buffer;