export const defProp = Object.defineProperty;
165011
function deepSet(targ, path, val) {
	var seg;

	while (seg = path.shift()) {
		if (path.length === 0)
			{ targ[seg] = val; }
		else
			{ targ[seg] = targ = targ[seg] || {}; }
	}
}
1155696
function(event, property, value) {
    try {
      Object.defineProperty(event, property, {
        get : function() {
          return value;
        }
      });
    } catch(e) {
      event[property] = value;
    }
  }
1018256
function(def) {
    def = def ? def : _.result(this, 'definition');

    return _.reduce(def, function(schema, attr, key) {
      if (attr.type === 'object') {
        schema[key] = this.schema(attr.fields || {});
      } else if (attr.type === 'array') {
        if (attr.value_type === 'object') {
          schema[key] = [this.schema(attr.fields || {})];
        } else if (attr.value_type) {
          schema[key] = [attr.value_type];
        } else {
          schema[key] = [];
        }
      } else {
        schema[key] = attr.type;
      }
      return schema;
    }.bind(this), {});
  }
568255
function determinePropertiesToGet (type) {
  const defaultProperties = ['description', 'summary']
  let result = defaultProperties
  switch (type) {
    case 'API':
      result.push('tags', 'info')
      break
    case 'METHOD':
      result.push('tags')
      break
  }
  return result

}
825610
function getPropertyDelim() {
  const type = NodeType.PropertyDelimType;
  const token = tokens[pos];
  const line = token.ln;
  const column = token.col;
  const content = ':';

  // Skip `:`.
  pos++;

  return newNode(type, content, line, column);
}
905736
function () {
    var Interface = this.constructor.Interface;
    for (var propName in Interface) {
      if ("development" !== 'production') {
        Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
      } else {
        this[propName] = null;
      }
    }
    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
      this[shouldBeReleasedProperties[i]] = null;
    }
    if ("development" !== 'production') {
      Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
      Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
      Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
    }
  }
457596
async function writeCustomPropertiesToMjsFile(to, customProperties) {
	const mjsContents = Object.keys(customProperties).reduce((mjsLines, name) => {
		mjsLines.push(`\t'${escapeForJS(name)}': '${escapeForJS(customProperties[name])}'`);

		return mjsLines;
	}, []).join(',\n');
	const mjs = `export const customProperties = {\n${mjsContents}\n};\n`;

	await writeFile(to, mjs);
}
317444
function (obj, prop, callback, callbackParams) {
                var value = obj[prop];

                Object.defineProperty(
                    obj,
                    prop,
                    {
                        get: function () {
                            return value;
                        },
                        set: function (newValue) {
                            value = newValue;
                            callback(newValue, callbackParams);
                        }
                    }
                );
            }
356352
function (scope, key, getter) {
      var value = null, args = Array.prototype.slice.call(arguments);
      var params = (args.length > 3) ? args.slice(3) : [];

      Object.defineProperty(scope, key, {
        get: function () {
          if (value === null) value = getter.apply(scope, params);
          return value;
        }
      });
    }
664662
function defineProp(obj, prop, getter) {
  if (Object.defineProperty) {
    Object.defineProperty(obj, prop, { get: getter });
  }
}
1120977
function getPropsType(component) {
  var propTypes = component.propTypes;
  var props = {};
  Object.keys(propTypes).forEach(function (k) {
    if (k !== '__strict__' && k !== '__subtype__') {
      props[k] = propTypes[k].tcomb;
    }
  });
  if (propTypes.hasOwnProperty('__subtype__')) {
    return t.refinement(t.struct(props), propTypes.__subtype__.predicate);
  }
  return t.struct(props);
}
1074578
function createPropsPrototype(props, parentProps, propTypes, componentClass) {
  const defaultProps = Object.create(null);

  Object.assign(defaultProps, parentProps, props);

  // Avoid freezing `id` prop
  const id = getComponentName(componentClass);
  delete props.id;

  // Add getters/setters for async prop properties
  Object.defineProperties(defaultProps, {
    // `id` is treated specially because layer might need to override it
    id: {
      configurable: false,
      writable: true,
      value: id
    }
  });

  // Add getters/setters for async prop properties
  addAsyncPropsToPropPrototype(defaultProps, propTypes);

  return defaultProps;
}
120097
function moduleDefine(exports, name, members) {
            var target = [exports];
            var publicNS = null;
            if (name) {
                publicNS = createNamespace(_Global, name);
                target.push(publicNS);
            }
            initializeProperties(target, members, name || "<ANONYMOUS>");
            return publicNS;
        }
878137
function define (prop, prototype) {
  Object.defineProperty(prototype, prop, {
      enumerable: true
    , get: function ( ) { return this.get.call(this._scope || this, prop); }
    , set: function (v) { return this.set.call(this._scope || this, prop, v); }
  });
}
879860
function getProperties(model) {
    const modelName = model.constructor.name;
    const properties = typed_conversions_1.hashToArray(exports.propertiesByModel[modelName], "property") || [];
    let parent = Object.getPrototypeOf(model.constructor);
    while (parent.name) {
        const subClass = new parent();
        const subClassName = subClass.constructor.name;
        properties.push(...typed_conversions_1.hashToArray(exports.propertiesByModel[subClassName], "property"));
        parent = Object.getPrototypeOf(subClass.constructor);
    }
    return properties;
}
657392
function Predef( definition ) {

		// Check for best case scenario: Array.
		// Copy the values of the array to data property.
		if ( definition instanceof Array ) {
			this.data = definition.slice(0);
			return;
		}

		// If it's an object, check for the deps and dict propreties.
		if ( definition.hasOwnProperty( 'deps' ) && definition.hasOwnProperty( 'dict' ) ){

			if ( !( definition.deps instanceof Array ) || !( definition.dict instanceof Array ) ) {
				throw new Error( 'Dict and depends property of definition must be Array' );
			}
			
			this.data = {
				deps: definition.deps.slice(0),
				dict: definition.dict.slice(0)
			};
			return;
		}
		
		// Not an array or valid Object
		throw new Error( 'Predef definition must be an Array or Object with deps and dict properties' );
	}
1149100
function allPropertiesOf(object) {
  function go(object) {
    const proto = prototypeOf(object);

    return proto       ?  propertiesOf(object).concat(go(proto))
    :      /* else */     propertiesOf(object);
  }

  return Array.from(new Set(go(object)));
}