Offset of value for property
540046
def value_offset(prop)
      src_range = prop.name_source_range
      src_range.start_pos.offset +
        (src_range.end_pos.offset - src_range.start_pos.offset) +
        whitespace_after_colon(prop).take_while { |w| w == ' ' }.size
    end
981067
def offset(value = nil, &block)
      chain { criteria.update_request_options from: block || Integer(value) }
    end
1204203
function offsetContainerProperty(offsetProperty, coordinates, diff) {
  return {
    ...coordinates,
    containerPosition: {
      ...coordinates.containerPosition,
      [offsetProperty]: coordinates.containerPosition[offsetProperty] + diff
    }
  };
}
94223
public function offsetSet($key, $value) {

        if (strpos($key, '/')) {

            $keys = explode('/', $key);
            $mem  = $this->props;

            foreach($keys as $keyname) {

                if (!isset($mem[$keyname])) {
                    $mem[$keyname] = new ArrayObject([]);
                }

                $mem = &$mem[$keyname];
            }

            $mem = $value;

        } else {
            $this->props[$key] = $value;
        }
    }
925027
function offset(elem) {
            elem = getRawNode(elem);

            var elemBCR = elem.getBoundingClientRect();
            return {
                width: Math.round(
                    Angular.isNumber(elemBCR.width)
                        ? elemBCR.width
                        : elem.offsetWidth
                ),
                height: Math.round(
                    Angular.isNumber(elemBCR.height)
                        ? elemBCR.height
                        : elem.offsetHeight
                ),
                top: Math.round(
                    elemBCR.top +
                        ($window.pageYOffset ||
                            $document[0].documentElement.scrollTop)
                ),
                left: Math.round(
                    elemBCR.left +
                        ($window.pageXOffset ||
                            $document[0].documentElement.scrollLeft)
                ),
            };
        }
1269762
public void setInt(int offset, int value)
  {
    byte []code = getCode();
    
    code[offset + 0]  = (byte) (value >> 24);
    code[offset + 1]  = (byte) (value >> 16);
    code[offset + 2]  = (byte) (value >> 8);
    code[offset + 3]  = (byte) (value);
  }
524784
def _apply_offset(self, offset):
        
        if not isinstance(offset, TimeValue):
            self.log_exc(u"offset is not an instance of TimeValue", None, True, TypeError)
        self.log([u"Applying offset %s", offset])
        self.smflist.offset(offset)
349393
def horizontal_offset(self, value):
        

        if value is not None:
            assert type(value) is int, "'{0}' attribute: '{1}' type is not 'int'!".format("horizontal_offset", value)
        self.__horizontal_offset = value
175247
function valueToX(value) {
    const
        rect = this.$.getBoundingClientRect(),
        percent = (value - this.min) / (this.max - this.min);
    return rect.width * percent;
}
1166594
function(x, y) {
		var offset = (x + y * this.width) * 4;
	
		return [
			this.data[offset + 0],
			this.data[offset + 1],
			this.data[offset + 2],
			this.data[offset + 3]
		];
	}
229948
private static int offsetFieldValue(ZoneOffset offset, TemporalField field) {
        int offsetSeconds = offset.getTotalSeconds();
        int value = LocalTime.ofSecondOfDay(Math.abs(offsetSeconds)).get(field);
        return offsetSeconds < 0 ? value * -1 : value;
    }
662194
def get_offset(self, request):
        """"""
        try:
            return _positive_int(
                get_query_param(request, self.offset_query_param),
            )
        except (KeyError, ValueError):
            return 0
506745
function (value, length, offset) {

                length = length || value.byteLength || value.length;
                var i;

                if (!length) {
                    return this;
                }

                if (undefined === offset) {
                    offset = this.offset;
                }

                if (length < 0 || offset + length > this.length) {
                    error.raise(10002, this.length, offset + length);
                }

                if (value instanceof ArrayBuffer) {
                    var view = new DataView(value, 0, length);
                    var littleEndian = this.littleEndian;

                    for (i = 0; i < length; ++i) {
                        this.view.setUint8(offset + i, view.getUint8(i, littleEndian), littleEndian);
                    }
                }
                else {
                    for (i = 0; i < length; ++i) {
                        this.view.setUint8(offset + i, value[i], littleEndian);
                    }
                }

                this.offset = offset + length;

                return this;
            }
16498
function getPositionFromOffset(el, of) {
  var offsetParent = getOffsetParent(el);
  var parentOf = getOffset(offsetParent);
  return {
    x: of.x - parentOf.x,
    y: of.y - parentOf.y
  };
}
51005
private int offset(long index) {
    int offset = (int) (index % buffer.length);
    if (offset < 0) {
      offset += buffer.length;
    }
    return offset;
  }
1364346
public function offsetSet($offset, $value)
    {
        $method = 'set' . ucfirst($offset);
        if (method_exists($this, $method)) {
            $this->{$method}($value);
        } else {
            $method = 'set' . self::matchPropertyName($offset);
            if (method_exists($this, $method)) {
                $this->{$method}($value);
            } else {
                $this->unknownProperties[$offset] = $value;
            }
        }
    }
461273
def Offset(self, vtableOffset):
        """"""

        vtable = self.Pos - self.Get(N.SOffsetTFlags, self.Pos)
        vtableEnd = self.Get(N.VOffsetTFlags, vtable)
        if vtableOffset < vtableEnd:
            return self.Get(N.VOffsetTFlags, vtable + vtableOffset)
        return 0