@devizovaburza/mdm-sdk 0.0.8 → 0.0.9

package/dist/v1/index.cjs

@@ -9,9 +9,6 @@ const z = require('zod/v4/core');
 require('node:fs');
 require('node:crypto');
 require('node:path');
-const require$$0 = require('buffer');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 function _interopNamespaceCompat(e) {
   if (e && typeof e === 'object' && 'default' in e) return e;
@@ -26,7 +23,6 @@ function _interopNamespaceCompat(e) {
 }
 
 const z__namespace = /*#__PURE__*/_interopNamespaceCompat(z);
-const require$$0__default = /*#__PURE__*/_interopDefaultCompat(require$$0);
 
 const createMdmClient = (baseUrl, options) => {
   return client.hc(baseUrl, options);
@@ -7902,123 +7898,6 @@ function requireEsprima () {
 	return esprima$1.exports;
 }
 
-var util = {};
-
-var hasRequiredUtil;
-
-function requireUtil () {
-	if (hasRequiredUtil) return util;
-	hasRequiredUtil = 1;
-	// Copyright Joyent, Inc. and other Node contributors.
-	//
-	// Permission is hereby granted, free of charge, to any person obtaining a
-	// copy of this software and associated documentation files (the
-	// "Software"), to deal in the Software without restriction, including
-	// without limitation the rights to use, copy, modify, merge, publish,
-	// distribute, sublicense, and/or sell copies of the Software, and to permit
-	// persons to whom the Software is furnished to do so, subject to the
-	// following conditions:
-	//
-	// The above copyright notice and this permission notice shall be included
-	// in all copies or substantial portions of the Software.
-	//
-	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-	// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-	// NOTE: These type checking functions intentionally don't use `instanceof`
-	// because it is fragile and can be easily faked with `Object.create()`.
-
-	function isArray(arg) {
-	  if (Array.isArray) {
-	    return Array.isArray(arg);
-	  }
-	  return objectToString(arg) === '[object Array]';
-	}
-	util.isArray = isArray;
-
-	function isBoolean(arg) {
-	  return typeof arg === 'boolean';
-	}
-	util.isBoolean = isBoolean;
-
-	function isNull(arg) {
-	  return arg === null;
-	}
-	util.isNull = isNull;
-
-	function isNullOrUndefined(arg) {
-	  return arg == null;
-	}
-	util.isNullOrUndefined = isNullOrUndefined;
-
-	function isNumber(arg) {
-	  return typeof arg === 'number';
-	}
-	util.isNumber = isNumber;
-
-	function isString(arg) {
-	  return typeof arg === 'string';
-	}
-	util.isString = isString;
-
-	function isSymbol(arg) {
-	  return typeof arg === 'symbol';
-	}
-	util.isSymbol = isSymbol;
-
-	function isUndefined(arg) {
-	  return arg === void 0;
-	}
-	util.isUndefined = isUndefined;
-
-	function isRegExp(re) {
-	  return objectToString(re) === '[object RegExp]';
-	}
-	util.isRegExp = isRegExp;
-
-	function isObject(arg) {
-	  return typeof arg === 'object' && arg !== null;
-	}
-	util.isObject = isObject;
-
-	function isDate(d) {
-	  return objectToString(d) === '[object Date]';
-	}
-	util.isDate = isDate;
-
-	function isError(e) {
-	  return (objectToString(e) === '[object Error]' || e instanceof Error);
-	}
-	util.isError = isError;
-
-	function isFunction(arg) {
-	  return typeof arg === 'function';
-	}
-	util.isFunction = isFunction;
-
-	function isPrimitive(arg) {
-	  return arg === null ||
-	         typeof arg === 'boolean' ||
-	         typeof arg === 'number' ||
-	         typeof arg === 'string' ||
-	         typeof arg === 'symbol' ||  // ES6 symbol
-	         typeof arg === 'undefined';
-	}
-	util.isPrimitive = isPrimitive;
-
-	util.isBuffer = require$$0__default.Buffer.isBuffer;
-
-	function objectToString(o) {
-	  return Object.prototype.toString.call(o);
-	}
-	return util;
-}
-
 /**
  * Default minimum size of a run.
  */
@@ -9115,14 +8994,6 @@ var hasRequiredCommon;
 function requireCommon () {
 	if (hasRequiredCommon) return common;
 	hasRequiredCommon = 1;
-	const {
-	  isObject,
-	  isArray,
-	  isString,
-	  isNumber,
-	  isFunction
-	} = requireUtil();
-
 	const PREFIX_BEFORE = 'before';
 	const PREFIX_AFTER_PROP = 'after-prop';
 	const PREFIX_AFTER_COLON = 'after-colon';
@@ -9160,6 +9031,57 @@ function requireCommon () {
 	const COLON = ':';
 	const UNDEFINED = undefined;
 
+	const LINE_BREAKS_BEFORE = new WeakMap();
+	const LINE_BREAKS_AFTER = new WeakMap();
+	const RAW_STRING_LITERALS = new WeakMap();
+
+	const is_string = subject => typeof subject === 'string';
+	const is_number = subject => typeof subject === 'number';
+	/**
+	 * @param {unknown} v
+	 * @returns {v is NonNullable<object>}
+	 */
+	const is_object = v => typeof v === 'object' && v !== null;
+
+	const normalize_key = key => is_string(key) || is_number(key)
+	  ? String(key)
+	  : null;
+
+	const set_raw_string_literal = (host, key, raw) => {
+	  if (!is_object(host) || !is_string(raw)) {
+	    return
+	  }
+
+	  const normalized = normalize_key(key);
+	  if (normalized === null) {
+	    return
+	  }
+
+	  let map = RAW_STRING_LITERALS.get(host);
+	  if (!map) {
+	    map = new Map();
+	    RAW_STRING_LITERALS.set(host, map);
+	  }
+
+	  map.set(normalized, raw);
+	};
+
+	const get_raw_string_literal = (host, key) => {
+	  if (!is_object(host)) {
+	    return
+	  }
+
+	  const normalized = normalize_key(key);
+	  if (normalized === null) {
+	    return
+	  }
+
+	  const map = RAW_STRING_LITERALS.get(host);
+	  return map
+	    ? map.get(normalized)
+	    : undefined
+	};
+
 	const symbol = (prefix, key) => Symbol.for(prefix + COLON + key);
 	const symbol_checked = (prefix, key) => {
 	  if (key) {
@@ -9247,7 +9169,7 @@ function requireCommon () {
 	// Assign keys and comments
 	const assign = (target, source, keys) => {
 	  keys.forEach(key => {
-	    if (!isString(key) && !isNumber(key)) {
+	    if (typeof key !== 'string' && typeof key !== 'number') {
 	      return
 	    }
 
@@ -9262,13 +9184,26 @@ function requireCommon () {
 	  return target
 	};
 
-	const is_raw_json = isFunction(JSON.isRawJSON)
+	const is_raw_json = typeof JSON.isRawJSON === 'function'
 	  // For backward compatibility,
 	  // since JSON.isRawJSON is not supported in node < 21
 	  ? JSON.isRawJSON
 	  // istanbul ignore next
 	  : () => false;
 
+	const set_comment_line_breaks = (comment, before, after) => {
+	  if (is_number(before) && before >= 0) {
+	    LINE_BREAKS_BEFORE.set(comment, before);
+	  }
+
+	  if (is_number(after) && after >= 0) {
+	    LINE_BREAKS_AFTER.set(comment, after);
+	  }
+	};
+
+	const get_comment_line_breaks_before = comment => LINE_BREAKS_BEFORE.get(comment);
+	const get_comment_line_breaks_after = comment => LINE_BREAKS_AFTER.get(comment);
+
 	common = {
 	  PROP_SYMBOL_PREFIXES,
 
@@ -9299,7 +9234,16 @@ function requireCommon () {
 	  swap_comments,
 	  assign_non_prop_comments,
 
+	  is_string,
+	  is_number,
+	  is_object,
+
 	  is_raw_json,
+	  set_raw_string_literal,
+	  get_raw_string_literal,
+	  set_comment_line_breaks,
+	  get_comment_line_breaks_before,
+	  get_comment_line_breaks_after,
 
 	  /**
 	   * Assign properties and comments from source to target object.
@@ -9330,11 +9274,11 @@ function requireCommon () {
 	   * assign(target, source, [])
 	   */
 	  assign (target, source, keys) {
-	    if (!isObject(target)) {
+	    if (!is_object(target)) {
 	      throw new TypeError('Cannot convert undefined or null to object')
 	    }
 
-	    if (!isObject(source)) {
+	    if (!is_object(source)) {
 	      return target
 	    }
 
@@ -9347,7 +9291,7 @@ function requireCommon () {
 	      // We assign non-property comments
 	      // if argument `keys` is not specified
 	      assign_non_prop_comments(target, source);
-	    } else if (!isArray(keys)) {
+	    } else if (!Array.isArray(keys)) {
 	      throw new TypeError('keys must be array or undefined')
 	    } else if (keys.length === 0) {
 	      // Copy all non-property comments from source to target
@@ -9405,7 +9349,7 @@ function requireCommon () {
 	    where: to_where,
 	    key: to_key
 	  }, override = false) {
-	    if (!isObject(source)) {
+	    if (!is_object(source)) {
 	      throw new TypeError('source must be an object')
 	    }
 
@@ -9413,7 +9357,7 @@ function requireCommon () {
 	      target = source;
 	    }
 
-	    if (!isObject(target)) {
+	    if (!is_object(target)) {
 	      // No target to move to
 	      return
 	    }
@@ -9468,7 +9412,7 @@ function requireCommon () {
 	    where,
 	    key
 	  }) {
-	    if (!isObject(target)) {
+	    if (!is_object(target)) {
 	      throw new TypeError('target must be an object')
 	    }
 
@@ -9489,7 +9433,6 @@ var hasRequiredArray;
 function requireArray () {
 	if (hasRequiredArray) return array;
 	hasRequiredArray = 1;
-	const {isArray} = requireUtil();
 	const {sort} = requireSrc$1();
 
 	const {
@@ -9739,7 +9682,7 @@ function requireArray () {
 
 	    items.forEach(item => {
 	      const prev = length;
-	      length += isArray(item)
+	      length += Array.isArray(item)
 	        ? item.length
 	        : 1;
 
@@ -9847,7 +9790,10 @@ function requireParse () {
 
 	  UNDEFINED,
 
+	  is_object,
 	  define,
+	  set_raw_string_literal,
+	  set_comment_line_breaks,
 	  assign_non_prop_comments
 	} = requireCommon();
 
@@ -10037,17 +9983,41 @@ function requireParse () {
 	      inline
 	    };
 
+	    const previous_line = last
+	      ? last.loc.end.line
+	      : 1;
+
+	    set_comment_line_breaks(
+	      comment,
+	      Math.max(0, comment.loc.start.line - previous_line)
+	    );
+
 	    // delete comment.loc
 	    comments.push(comment);
 
 	    next();
 	  }
 
+	  const {length} = comments;
+
+	  if (length) {
+	    const comment = comments[length - 1];
+	    const current_line = current
+	      ? current.loc.start.line
+	      : comment.loc.end.line;
+
+	    set_comment_line_breaks(
+	      comment,
+	      undefined,
+	      Math.max(0, current_line - comment.loc.end.line)
+	    );
+	  }
+
 	  if (remove_comments) {
 	    return
 	  }
 
-	  if (!comments.length) {
+	  if (!length) {
 	    return
 	  }
 
@@ -10226,6 +10196,8 @@ function requireParse () {
 
 	  switch (tt) {
 	  case 'String':
+	    set_raw_string_literal(comments_host, last_prop, current.value);
+	    // falls through
 	  case 'Boolean':
 	  case 'Null':
 	  case 'Numeric':
@@ -10245,8 +10217,6 @@ function requireParse () {
 	  }
 	}
 
-	const isObject = subject => Object(subject) === subject;
-
 	/**
 	 * Converts a JavaScript Object Notation (JSON) string with comments into an
 	 * object.
@@ -10310,7 +10280,7 @@ function requireParse () {
 	  // We should run reviver before the checks below,
 	  // otherwise the comment info will be lost
 	  if (!no_comments && result !== null) {
-	    if (!isObject(result)) {
+	    if (!is_object(result)) {
 	      // 1 -> new Number(1)
 	      // true -> new Boolean(1)
 	      // "foo" -> new String("foo")
@@ -10342,10 +10312,6 @@ var hasRequiredStringify;
 function requireStringify () {
 	if (hasRequiredStringify) return stringify_1;
 	hasRequiredStringify = 1;
-	const {
-	  isArray, isObject, isFunction, isNumber, isString
-	} = requireUtil();
-
 	const {
 	  PREFIX_BEFORE_ALL,
 	  PREFIX_BEFORE,
@@ -10365,12 +10331,17 @@ function requireStringify () {
 
 	  UNDEFINED,
 
+	  is_string,
+	  is_number,
+	  is_object,
+
+	  get_raw_string_literal,
+	  get_comment_line_breaks_before,
+	  get_comment_line_breaks_after,
+
 	  is_raw_json
 	} = requireCommon();
 
-	// eslint-disable-next-line no-control-regex, no-misleading-character-class
-	const ESCAPABLE = /[\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
-
 	// String constants
 	const SPACE = ' ';
 	const LF = '\n';
@@ -10383,39 +10354,54 @@ function requireStringify () {
 	const AFTER_VALUE = prop => `${PREFIX_AFTER_VALUE}:${prop}`;
 	const AFTER = prop => `${PREFIX_AFTER}:${prop}`;
 
-	// table of character substitutions
-	const meta = {
-	  '\b': '\\b',
-	  '\t': '\\t',
-	  '\n': '\\n',
-	  '\f': '\\f',
-	  '\r': '\\r',
-	  '"': '\\"',
-	  '\\': '\\\\'
-	};
+	const quote = JSON.stringify;
+	const comment_stringify = (value, line) => line
+	  ? `//${value}`
+	  : `/*${value}*/`;
+	const repeat_line_breaks = (line_breaks, gap) => (LF + gap).repeat(line_breaks);
+	const read_line_breaks = line_breaks => is_number(line_breaks) && line_breaks >= 0
+	  ? line_breaks
+	  : null;
+	const read_line_breaks_from_loc = (previous_comment, comment) => {
+	  if (
+	    !previous_comment
+	    || !previous_comment.loc
+	    || !comment.loc
+	  ) {
+	    return null
+	  }
 
-	const escape = string => {
-	  ESCAPABLE.lastIndex = 0;
+	  const {end} = previous_comment.loc;
+	  const {start} = comment.loc;
 
-	  if (!ESCAPABLE.test(string)) {
-	    return string
+	  if (
+	    !end
+	    || !start
+	    || !is_number(end.line)
+	    || !is_number(start.line)
+	  ) {
+	    return null
 	  }
 
-	  return string.replace(ESCAPABLE, a => {
-	    const c = meta[a];
-	    return typeof c === 'string'
-	      ? c
-	      : a
-	  })
+	  const line_breaks = start.line - end.line;
+
+	  return line_breaks >= 0
+	    ? line_breaks
+	    : null
 	};
+	const count_trailing_line_breaks = (str, gap) => {
+	  const unit = LF + gap;
+	  const {length} = unit;
+	  let i = str.length;
+	  let count = 0;
+
+	  while (i >= length && str.slice(i - length, i) === unit) {
+	    i -= length;
+	    count ++;
+	  }
 
-	// Escape no control characters, no quote characters,
-	// and no backslash characters,
-	// then we can safely slap some quotes around it.
-	const quote = string => `"${escape(string)}"`;
-	const comment_stringify = (value, line) => line
-	  ? `//${value}`
-	  : `/*${value}*/`;
+	  return count
+	};
 
 	// display_block `boolean` whether the
 	//   WHOLE block of comments is always a block group
@@ -10425,27 +10411,58 @@ function requireStringify () {
 	    return EMPTY
 	  }
 
-	  let is_line_comment = false;
+	  let str = EMPTY;
+	  let last_comment = null;
 
-	  const str = comments.reduce((prev, {
-	    inline,
-	    type,
-	    value
-	  }) => {
-	    const delimiter = inline
-	      ? SPACE
-	      : LF + deeper_gap;
+	  comments.forEach((comment, i) => {
+	    const {
+	      inline,
+	      type,
+	      value
+	    } = comment;
 
-	    is_line_comment = type === 'LineComment';
+	    let line_breaks_before = read_line_breaks(
+	      get_comment_line_breaks_before(comment)
+	    );
 
-	    return prev + delimiter + comment_stringify(value, is_line_comment)
-	  }, EMPTY);
+	    if (line_breaks_before === null) {
+	      line_breaks_before = read_line_breaks_from_loc(last_comment, comment);
+	    }
 
-	  return display_block
-	  // line comment should always end with a LF
-	  || is_line_comment
-	    ? str + LF + deeper_gap
-	    : str
+	    if (line_breaks_before === null) {
+	      line_breaks_before = inline
+	        ? 0
+	        : 1;
+	    }
+
+	    const delimiter = line_breaks_before > 0
+	      ? repeat_line_breaks(line_breaks_before, deeper_gap)
+	      : inline
+	        ? SPACE
+	        // The first comment at the very beginning of the source.
+	        : i === 0
+	          ? EMPTY
+	          : LF + deeper_gap;
+
+	    const is_line_comment = type === 'LineComment';
+
+	    str += delimiter + comment_stringify(value, is_line_comment);
+
+	    last_comment = comment;
+	  });
+
+	  const default_line_breaks_after = display_block
+	    // line comment should always end with a LF
+	    || last_comment.type === 'LineComment'
+	    ? 1
+	    : 0;
+
+	  const line_breaks_after = Math.max(
+	    default_line_breaks_after,
+	    read_line_breaks(get_comment_line_breaks_after(last_comment)) || 0
+	  );
+
+	  return str + repeat_line_breaks(line_breaks_after, deeper_gap)
 	};
 
 	let replacer = null;
@@ -10464,9 +10481,15 @@ function requireStringify () {
 	      // and make a mistake.
 	      // SO, we are not to only trimRight but trim for both sides
 	      ? one + two.trim() + LF + gap
-	      : one.trimRight() + LF + gap
+	      : one.trimRight() + repeat_line_breaks(
+	        Math.max(1, count_trailing_line_breaks(one, gap)),
+	        gap
+	      )
 	    : two
-	      ? two.trimRight() + LF + gap
+	      ? two.trimRight() + repeat_line_breaks(
+	        Math.max(1, count_trailing_line_breaks(two, gap)),
+	        gap
+	      )
 	      : EMPTY;
 
 	const join_content = (inside, value, gap) => {
@@ -10475,6 +10498,21 @@ function requireStringify () {
 	  return join(comment, inside, gap)
 	};
 
+	const stringify_string = (holder, key, value) => {
+	  const raw = get_raw_string_literal(holder, key);
+	  if (is_string(raw)) {
+	    try {
+	      if (JSON.parse(raw) === value) {
+	        return raw
+	      }
+	    } catch (e) {
+	      // ignore invalid raw string literals and fallback to native behavior
+	    }
+	  }
+
+	  return quote(value)
+	};
+
 	// | deeper_gap   |
 	// | gap | indent |
 	//       [
@@ -10544,7 +10582,7 @@ function requireStringify () {
 	  let after_comma = EMPTY;
 	  let first = true;
 
-	  const keys = isArray(replacer)
+	  const keys = Array.isArray(replacer)
 	    ? replacer
 	    : Object.keys(value);
 
@@ -10609,19 +10647,19 @@ function requireStringify () {
 	  let value = holder[key];
 
 	  // If the value has a toJSON method, call it to obtain a replacement value.
-	  if (isObject(value) && isFunction(value.toJSON)) {
+	  if (is_object(value) && typeof value.toJSON === 'function') {
 	    value = value.toJSON(key);
 	  }
 
 	  // If we were called with a replacer function, then call the replacer to
 	  // obtain a replacement value.
-	  if (isFunction(replacer)) {
+	  if (typeof replacer === 'function') {
 	    value = replacer.call(holder, key, value);
 	  }
 
 	  switch (typeof value) {
 	  case 'string':
-	    return quote(value)
+	    return stringify_string(holder, key, value)
 
 	  case 'number':
 	    // JSON numbers must be finite. Encode non-finite numbers as null.
@@ -10642,7 +10680,7 @@ function requireStringify () {
 	      return value.rawJSON
 	    }
 
-	    return isArray(value)
+	    return Array.isArray(value)
 	      ? array_stringify(value, gap)
 	      : object_stringify(value, gap)
 	    // JSON.stringify(undefined) === undefined
@@ -10650,10 +10688,10 @@ function requireStringify () {
 	  }
 	}
 
-	const get_indent = space => isString(space)
+	const get_indent = space => typeof space === 'string'
 	  // If the space parameter is a string, it will be used as the indent string.
 	  ? space
-	  : isNumber(space)
+	  : typeof space === 'number'
 	    ? SPACE.repeat(space)
 	    : EMPTY;
 
@@ -10716,7 +10754,7 @@ function requireStringify () {
 	  }
 
 	  // vanilla `JSON.parse` allow invalid replacer
-	  if (!isFunction(replacer_) && !isArray(replacer_)) {
+	  if (typeof replacer_ !== 'function' && !Array.isArray(replacer_)) {
 	    replacer_ = null;
 	  }
 
@@ -10729,7 +10767,7 @@ function requireStringify () {
 
 	  clean();
 
-	  return isObject(value)
+	  return is_object(value)
 	    ? process_comments(value, PREFIX_BEFORE_ALL, EMPTY, true).trimLeft()
 	      + str
 	      + process_comments(value, PREFIX_AFTER_ALL, EMPTY).trimRight()