dmg-builder 26.5.0 → 26.7.0

package/vendor/mac_alias/bookmark.py

@@ -1,677 +0,0 @@
-#  This file implements the Apple "bookmark" format, which is the replacement
-#  for the old-fashioned alias format.  The details of this format were
-#  reverse engineered; some things are still not entirely clear.
-#
-import datetime
-import os
-import struct
-import sys
-import uuid
-from urllib.parse import urljoin
-
-if sys.platform == "darwin":
-    from . import osx
-
-from .utils import osx_epoch
-
-BMK_DATA_TYPE_MASK = 0xFFFFFF00
-BMK_DATA_SUBTYPE_MASK = 0x000000FF
-
-BMK_STRING = 0x0100
-BMK_DATA = 0x0200
-BMK_NUMBER = 0x0300
-BMK_DATE = 0x0400
-BMK_BOOLEAN = 0x0500
-BMK_ARRAY = 0x0600
-BMK_DICT = 0x0700
-BMK_UUID = 0x0800
-BMK_URL = 0x0900
-BMK_NULL = 0x0A00
-
-BMK_ST_ZERO = 0x0000
-BMK_ST_ONE = 0x0001
-
-BMK_BOOLEAN_ST_FALSE = 0x0000
-BMK_BOOLEAN_ST_TRUE = 0x0001
-
-# Subtypes for BMK_NUMBER are really CFNumberType values
-kCFNumberSInt8Type = 1
-kCFNumberSInt16Type = 2
-kCFNumberSInt32Type = 3
-kCFNumberSInt64Type = 4
-kCFNumberFloat32Type = 5
-kCFNumberFloat64Type = 6
-kCFNumberCharType = 7
-kCFNumberShortType = 8
-kCFNumberIntType = 9
-kCFNumberLongType = 10
-kCFNumberLongLongType = 11
-kCFNumberFloatType = 12
-kCFNumberDoubleType = 13
-kCFNumberCFIndexType = 14
-kCFNumberNSIntegerType = 15
-kCFNumberCGFloatType = 16
-
-# Resource property flags (from CFURLPriv.h)
-kCFURLResourceIsRegularFile = 0x00000001
-kCFURLResourceIsDirectory = 0x00000002
-kCFURLResourceIsSymbolicLink = 0x00000004
-kCFURLResourceIsVolume = 0x00000008
-kCFURLResourceIsPackage = 0x00000010
-kCFURLResourceIsSystemImmutable = 0x00000020
-kCFURLResourceIsUserImmutable = 0x00000040
-kCFURLResourceIsHidden = 0x00000080
-kCFURLResourceHasHiddenExtension = 0x00000100
-kCFURLResourceIsApplication = 0x00000200
-kCFURLResourceIsCompressed = 0x00000400
-kCFURLResourceIsSystemCompressed = 0x00000400
-kCFURLCanSetHiddenExtension = 0x00000800
-kCFURLResourceIsReadable = 0x00001000
-kCFURLResourceIsWriteable = 0x00002000
-kCFURLResourceIsExecutable = 0x00004000
-kCFURLIsAliasFile = 0x00008000
-kCFURLIsMountTrigger = 0x00010000
-
-# Volume property flags (from CFURLPriv.h)
-kCFURLVolumeIsLocal = 0x1
-kCFURLVolumeIsAutomount = 0x2
-kCFURLVolumeDontBrowse = 0x4
-kCFURLVolumeIsReadOnly = 0x8
-kCFURLVolumeIsQuarantined = 0x10
-kCFURLVolumeIsEjectable = 0x20
-kCFURLVolumeIsRemovable = 0x40
-kCFURLVolumeIsInternal = 0x80
-kCFURLVolumeIsExternal = 0x100
-kCFURLVolumeIsDiskImage = 0x200
-kCFURLVolumeIsFileVault = 0x400
-kCFURLVolumeIsLocaliDiskMirror = 0x800
-kCFURLVolumeIsiPod = 0x1000
-kCFURLVolumeIsiDisk = 0x2000
-kCFURLVolumeIsCD = 0x4000
-kCFURLVolumeIsDVD = 0x8000
-kCFURLVolumeIsDeviceFileSystem = 0x10000
-kCFURLVolumeSupportsPersistentIDs = 0x100000000
-kCFURLVolumeSupportsSearchFS = 0x200000000
-kCFURLVolumeSupportsExchange = 0x400000000
-# reserved                                           0x800000000
-kCFURLVolumeSupportsSymbolicLinks = 0x1000000000
-kCFURLVolumeSupportsDenyModes = 0x2000000000
-kCFURLVolumeSupportsCopyFile = 0x4000000000
-kCFURLVolumeSupportsReadDirAttr = 0x8000000000
-kCFURLVolumeSupportsJournaling = 0x10000000000
-kCFURLVolumeSupportsRename = 0x20000000000
-kCFURLVolumeSupportsFastStatFS = 0x40000000000
-kCFURLVolumeSupportsCaseSensitiveNames = 0x80000000000
-kCFURLVolumeSupportsCasePreservedNames = 0x100000000000
-kCFURLVolumeSupportsFLock = 0x200000000000
-kCFURLVolumeHasNoRootDirectoryTimes = 0x400000000000
-kCFURLVolumeSupportsExtendedSecurity = 0x800000000000
-kCFURLVolumeSupports2TBFileSize = 0x1000000000000
-kCFURLVolumeSupportsHardLinks = 0x2000000000000
-kCFURLVolumeSupportsMandatoryByteRangeLocks = 0x4000000000000
-kCFURLVolumeSupportsPathFromID = 0x8000000000000
-# reserved                                      0x10000000000000
-kCFURLVolumeIsJournaling = 0x20000000000000
-kCFURLVolumeSupportsSparseFiles = 0x40000000000000
-kCFURLVolumeSupportsZeroRuns = 0x80000000000000
-kCFURLVolumeSupportsVolumeSizes = 0x100000000000000
-kCFURLVolumeSupportsRemoteEvents = 0x200000000000000
-kCFURLVolumeSupportsHiddenFiles = 0x400000000000000
-kCFURLVolumeSupportsDecmpFSCompression = 0x800000000000000
-kCFURLVolumeHas64BitObjectIDs = 0x1000000000000000
-kCFURLVolumePropertyFlagsAll = 0xFFFFFFFFFFFFFFFF
-
-BMK_URL_ST_ABSOLUTE = 0x0001
-BMK_URL_ST_RELATIVE = 0x0002
-
-# Bookmark keys
-kBookmarkURL = 0x1003  # A URL
-kBookmarkPath = 0x1004  # Array of path components
-kBookmarkCNIDPath = 0x1005  # Array of CNIDs
-kBookmarkFileProperties = (
-    0x1010  # (CFURL rp flags, CFURL rp flags asked for, 8 bytes NULL)
-)
-kBookmarkFileName = 0x1020
-kBookmarkFileID = 0x1030
-kBookmarkFileCreationDate = 0x1040
-# = 0x1054   # ?
-# = 0x1055   # ?
-# = 0x1056   # ?
-# = 0x1101   # ?
-# = 0x1102   # ?
-kBookmarkTOCPath = 0x2000  # A list of (TOC id, ?) pairs
-kBookmarkVolumePath = 0x2002
-kBookmarkVolumeURL = 0x2005
-kBookmarkVolumeName = 0x2010
-kBookmarkVolumeUUID = 0x2011  # Stored (perversely) as a string
-kBookmarkVolumeSize = 0x2012
-kBookmarkVolumeCreationDate = 0x2013
-kBookmarkVolumeProperties = (
-    0x2020  # (CFURL vp flags, CFURL vp flags asked for, 8 bytes NULL)
-)
-kBookmarkVolumeIsRoot = 0x2030  # True if volume is FS root
-kBookmarkVolumeBookmark = 0x2040  # Embedded bookmark for disk image (TOC id)
-kBookmarkVolumeMountPoint = 0x2050  # A URL
-# = 0x2070
-kBookmarkContainingFolder = 0xC001  # Index of containing folder in path
-kBookmarkUserName = 0xC011  # User that created bookmark
-kBookmarkUID = 0xC012  # UID that created bookmark
-kBookmarkWasFileReference = 0xD001  # True if the URL was a file reference
-kBookmarkCreationOptions = 0xD010
-kBookmarkURLLengths = 0xE003  # See below
-kBookmarkDisplayName = 0xF017
-kBookmarkIconData = 0xF020
-kBookmarkIconRef = 0xF021
-kBookmarkTypeBindingData = 0xF022
-kBookmarkCreationTime = 0xF030
-kBookmarkSandboxRwExtension = 0xF080
-kBookmarkSandboxRoExtension = 0xF081
-kBookmarkAliasData = 0xFE00
-
-# Alias for backwards compatibility
-kBookmarkSecurityExtension = kBookmarkSandboxRwExtension
-
-# kBookmarkURLLengths is an array that is set if the URL encoded by the
-# bookmark had a base URL; in that case, each entry is the length of the
-# base URL in question.  Thus a URL
-#
-#     file:///foo/bar/baz    blam/blat.html
-#
-# will result in [3, 2], while the URL
-#
-#     file:///foo    bar/baz    blam    blat.html
-#
-# would result in [1, 2, 1, 1]
-
-
-class Data:
-    def __init__(self, bytedata=None):
-        #: The bytes, stored as a byte string
-        self.bytes = bytes(bytedata)
-
-    def __repr__(self):
-        return "Data(%r)" % self.bytes
-
-
-class URL:
-    def __init__(self, base, rel=None):
-        if rel is not None:
-            #: The base URL, if any (a :class:`URL`)
-            self.base = base
-            #: The rest of the URL (a string)
-            self.relative = rel
-        else:
-            self.base = None
-            self.relative = base
-
-    @property
-    def absolute(self):
-        """Return an absolute URL."""
-        if self.base is None:
-            return self.relative
-        else:
-            return urljoin(self.base.absolute, self.relative)
-
-    def __repr__(self):
-        return "URL(%r)" % self.absolute
-
-
-class Bookmark:
-    def __init__(self, tocs=None):
-        if tocs is None:
-            #: The TOCs for this Bookmark
-            self.tocs = []
-        else:
-            self.tocs = tocs
-
-    @classmethod
-    def _get_item(cls, data, hdrsize, offset):
-        offset += hdrsize
-        if offset > len(data) - 8:
-            raise ValueError("Offset out of range")
-
-        length, typecode = struct.unpack(b"<II", data[offset : offset + 8])
-
-        if len(data) - offset < 8 + length:
-            raise ValueError("Data item truncated")
-
-        databytes = data[offset + 8 : offset + 8 + length]
-
-        dsubtype = typecode & BMK_DATA_SUBTYPE_MASK
-        dtype = typecode & BMK_DATA_TYPE_MASK
-
-        if dtype == BMK_STRING:
-            return databytes.decode("utf-8")
-        elif dtype == BMK_DATA:
-            return Data(databytes)
-        elif dtype == BMK_NUMBER:
-            if dsubtype == kCFNumberSInt8Type:
-                return ord(databytes[0])
-            elif dsubtype == kCFNumberSInt16Type:
-                return struct.unpack(b"<h", databytes)[0]
-            elif dsubtype == kCFNumberSInt32Type:
-                return struct.unpack(b"<i", databytes)[0]
-            elif dsubtype == kCFNumberSInt64Type:
-                return struct.unpack(b"<q", databytes)[0]
-            elif dsubtype == kCFNumberFloat32Type:
-                return struct.unpack(b"<f", databytes)[0]
-            elif dsubtype == kCFNumberFloat64Type:
-                return struct.unpack(b"<d", databytes)[0]
-        elif dtype == BMK_DATE:
-            # Yes, dates really are stored as *BIG-endian* doubles; everything
-            # else is little-endian
-            secs = datetime.timedelta(seconds=struct.unpack(b">d", databytes)[0])
-            return osx_epoch + secs
-        elif dtype == BMK_BOOLEAN:
-            if dsubtype == BMK_BOOLEAN_ST_TRUE:
-                return True
-            elif dsubtype == BMK_BOOLEAN_ST_FALSE:
-                return False
-        elif dtype == BMK_UUID:
-            return uuid.UUID(bytes=databytes)
-        elif dtype == BMK_URL:
-            if dsubtype == BMK_URL_ST_ABSOLUTE:
-                return URL(databytes.decode("utf-8"))
-            elif dsubtype == BMK_URL_ST_RELATIVE:
-                baseoff, reloff = struct.unpack(b"<II", databytes)
-                base = cls._get_item(data, hdrsize, baseoff)
-                rel = cls._get_item(data, hdrsize, reloff)
-                return URL(base, rel)
-        elif dtype == BMK_ARRAY:
-            result = []
-            for aoff in range(offset + 8, offset + 8 + length, 4):
-                (eltoff,) = struct.unpack(b"<I", data[aoff : aoff + 4])
-                result.append(cls._get_item(data, hdrsize, eltoff))
-            return result
-        elif dtype == BMK_DICT:
-            result = {}
-            for eoff in range(offset + 8, offset + 8 + length, 8):
-                keyoff, valoff = struct.unpack(b"<II", data[eoff : eoff + 8])
-                key = cls._get_item(data, hdrsize, keyoff)
-                val = cls._get_item(data, hdrsize, valoff)
-                result[key] = val
-            return result
-        elif dtype == BMK_NULL:
-            return None
-
-        print("Unknown data type %08x" % typecode)
-        return (typecode, databytes)
-
-    @classmethod
-    def from_bytes(cls, data):
-        """Create a :class:`Bookmark` given byte data."""
-
-        if len(data) < 16:
-            raise ValueError("Not a bookmark file (too short)")
-
-        if isinstance(data, bytearray):
-            data = bytes(data)
-
-        magic, size, dummy, hdrsize = struct.unpack(b"<4sIII", data[0:16])
-
-        if magic not in (b"book", b"alis"):
-            raise ValueError("Not a bookmark file (bad magic) %r" % magic)
-
-        if hdrsize < 16:
-            raise ValueError("Not a bookmark file (header size too short)")
-
-        if hdrsize > size:
-            raise ValueError("Not a bookmark file (header size too large)")
-
-        if size != len(data):
-            raise ValueError("Not a bookmark file (truncated)")
-
-        (tocoffset,) = struct.unpack(b"<I", data[hdrsize : hdrsize + 4])
-
-        tocs = []
-
-        while tocoffset != 0:
-            tocbase = hdrsize + tocoffset
-            if (tocoffset > size - hdrsize) or (size - tocbase < 20):
-                raise ValueError("TOC offset out of range")
-
-            (tocsize, tocmagic, tocid, nexttoc, toccount) = struct.unpack(
-                b"<IIIII", data[tocbase : tocbase + 20]
-            )
-
-            if tocmagic != 0xFFFFFFFE:
-                break
-
-            tocsize += 8
-
-            if size - tocbase < tocsize:
-                raise ValueError("TOC truncated")
-
-            if tocsize < 12 * toccount:
-                raise ValueError("TOC entries overrun TOC size")
-
-            toc = {}
-            for n in range(0, toccount):
-                ebase = tocbase + 20 + 12 * n
-                eid, eoffset, edummy = struct.unpack(b"<III", data[ebase : ebase + 12])
-
-                if eid & 0x80000000:
-                    eid = cls._get_item(data, hdrsize, eid & 0x7FFFFFFF)
-
-                toc[eid] = cls._get_item(data, hdrsize, eoffset)
-
-            tocs.append((tocid, toc))
-
-            tocoffset = nexttoc
-
-        return cls(tocs)
-
-    def __getitem__(self, key):
-        for tid, toc in self.tocs:
-            if key in toc:
-                return toc[key]
-        raise KeyError("Key not found")
-
-    def __setitem__(self, key, value):
-        if len(self.tocs) == 0:
-            self.tocs = [(1, {})]
-        self.tocs[0][1][key] = value
-
-    def get(self, key, default=None):
-        """Lookup the value for a given key, returning a default if not
-        present."""
-        for tid, toc in self.tocs:
-            if key in toc:
-                return toc[key]
-        return default
-
-    @classmethod
-    def _encode_item(cls, item, offset):
-        if item is True:
-            result = struct.pack(b"<II", 0, BMK_BOOLEAN | BMK_BOOLEAN_ST_TRUE)
-        elif item is False:
-            result = struct.pack(b"<II", 0, BMK_BOOLEAN | BMK_BOOLEAN_ST_FALSE)
-        elif isinstance(item, str):
-            encoded = item.encode("utf-8")
-            result = (
-                struct.pack(b"<II", len(encoded), BMK_STRING | BMK_ST_ONE) + encoded
-            )
-        elif isinstance(item, bytes):
-            result = struct.pack(b"<II", len(item), BMK_STRING | BMK_ST_ONE) + item
-        elif isinstance(item, Data):
-            result = struct.pack(
-                b"<II", len(item.bytes), BMK_DATA | BMK_ST_ONE
-            ) + bytes(item.bytes)
-        elif isinstance(item, bytearray):
-            result = struct.pack(b"<II", len(item), BMK_DATA | BMK_ST_ONE) + bytes(item)
-        elif isinstance(item, int):
-            if item > -0x80000000 and item < 0x7FFFFFFF:
-                result = struct.pack(b"<IIi", 4, BMK_NUMBER | kCFNumberSInt32Type, item)
-            else:
-                result = struct.pack(b"<IIq", 8, BMK_NUMBER | kCFNumberSInt64Type, item)
-        elif isinstance(item, float):
-            result = struct.pack(b"<IId", 8, BMK_NUMBER | kCFNumberFloat64Type, item)
-        elif isinstance(item, datetime.datetime):
-            secs = item - osx_epoch
-            result = struct.pack(b"<II", 8, BMK_DATE | BMK_ST_ZERO) + struct.pack(
-                b">d", float(secs.total_seconds())
-            )
-
-        elif isinstance(item, uuid.UUID):
-            result = struct.pack(b"<II", 16, BMK_UUID | BMK_ST_ONE) + item.bytes
-        elif isinstance(item, URL):
-            if item.base:
-                baseoff = offset + 16
-                reloff, baseenc = cls._encode_item(item.base, baseoff)
-                xoffset, relenc = cls._encode_item(item.relative, reloff)
-                result = b"".join(
-                    [
-                        struct.pack(
-                            b"<IIII", 8, BMK_URL | BMK_URL_ST_RELATIVE, baseoff, reloff
-                        ),
-                        baseenc,
-                        relenc,
-                    ]
-                )
-            else:
-                encoded = item.relative.encode("utf-8")
-                result = (
-                    struct.pack(b"<II", len(encoded), BMK_URL | BMK_URL_ST_ABSOLUTE)
-                    + encoded
-                )
-        elif isinstance(item, list):
-            ioffset = offset + 8 + len(item) * 4
-            result = [struct.pack(b"<II", len(item) * 4, BMK_ARRAY | BMK_ST_ONE)]
-            enc = []
-            for elt in item:
-                result.append(struct.pack(b"<I", ioffset))
-                ioffset, ienc = cls._encode_item(elt, ioffset)
-                enc.append(ienc)
-            result = b"".join(result + enc)
-        elif isinstance(item, dict):
-            ioffset = offset + 8 + len(item) * 8
-            result = [struct.pack(b"<II", len(item) * 8, BMK_DICT | BMK_ST_ONE)]
-            enc = []
-            for k, v in item.items():
-                result.append(struct.pack(b"<I", ioffset))
-                ioffset, ienc = cls._encode_item(k, ioffset)
-                enc.append(ienc)
-                result.append(struct.pack(b"<I", ioffset))
-                ioffset, ienc = cls._encode_item(v, ioffset)
-                enc.append(ienc)
-            result = b"".join(result + enc)
-        elif item is None:
-            result = struct.pack(b"<II", 0, BMK_NULL | BMK_ST_ONE)
-        else:
-            raise ValueError("Unknown item type when encoding: %s" % item)
-
-        offset += len(result)
-
-        # Pad to a multiple of 4 bytes
-        if offset & 3:
-            extra = 4 - (offset & 3)
-            result += b"\0" * extra
-            offset += extra
-
-        return (offset, result)
-
-    def to_bytes(self):
-        """Convert this :class:`Bookmark` to a byte representation."""
-
-        result = []
-        tocs = []
-        offset = 4  # For the offset to the first TOC
-
-        # Generate the data and build the TOCs
-        for tid, toc in self.tocs:
-            entries = []
-
-            for k, v in toc.items():
-                if isinstance(k, str):
-                    noffset = offset
-                    voffset, enc = self._encode_item(k, offset)
-                    result.append(enc)
-                    offset, enc = self._encode_item(v, voffset)
-                    result.append(enc)
-                    entries.append((noffset | 0x80000000, voffset))
-                else:
-                    entries.append((k, offset))
-                    offset, enc = self._encode_item(v, offset)
-                    result.append(enc)
-
-            # TOC entries must be sorted - CoreServicesInternal does a
-            # binary search to find data
-            entries.sort()
-
-            tocs.append(
-                (tid, b"".join([struct.pack(b"<III", k, o, 0) for k, o in entries]))
-            )
-
-        first_toc_offset = offset
-
-        # Now generate the TOC headers
-        for ndx, toc in enumerate(tocs):
-            tid, data = toc
-            if ndx == len(tocs) - 1:
-                next_offset = 0
-            else:
-                next_offset = offset + 20 + len(data)
-
-            result.append(
-                struct.pack(
-                    b"<IIIII",
-                    len(data) - 8,
-                    0xFFFFFFFE,
-                    tid,
-                    next_offset,
-                    len(data) // 12,
-                )
-            )
-            result.append(data)
-
-            offset += 20 + len(data)
-
-        # Finally, add the header (and the first TOC offset, which isn't part
-        # of the header, but goes just after it)
-        header = struct.pack(
-            b"<4sIIIQQQQI",
-            b"book",
-            offset + 48,
-            0x10040000,
-            48,
-            0,
-            0,
-            0,
-            0,
-            first_toc_offset,
-        )
-
-        result.insert(0, header)
-
-        return b"".join(result)
-
-    @classmethod
-    def for_file(cls, path):
-        """Construct a :class:`Bookmark` for a given file."""
-
-        # Find the filesystem
-        st = osx.statfs(path)
-        vol_path = st.f_mntonname.decode("utf-8")
-
-        # Grab its attributes
-        attrs = [
-            osx.ATTR_CMN_CRTIME,
-            osx.ATTR_VOL_SIZE | osx.ATTR_VOL_NAME | osx.ATTR_VOL_UUID,
-            0,
-            0,
-            0,
-        ]
-        volinfo = osx.getattrlist(vol_path, attrs, 0)
-
-        vol_crtime = volinfo[0]
-        vol_size = volinfo[1]
-        vol_name = volinfo[2]
-        vol_uuid = volinfo[3]
-
-        # Also grab various attributes of the file
-        attrs = [
-            (osx.ATTR_CMN_OBJTYPE | osx.ATTR_CMN_CRTIME | osx.ATTR_CMN_FILEID),
-            0,
-            0,
-            0,
-            0,
-        ]
-        info = osx.getattrlist(path, attrs, osx.FSOPT_NOFOLLOW)
-
-        cnid = info[2]
-        crtime = info[1]
-
-        if info[0] == osx.VREG:
-            flags = kCFURLResourceIsRegularFile
-        elif info[0] == osx.VDIR:
-            flags = kCFURLResourceIsDirectory
-        elif info[0] == osx.VLNK:
-            flags = kCFURLResourceIsSymbolicLink
-        else:
-            flags = kCFURLResourceIsRegularFile
-
-        dirname, filename = os.path.split(path)
-
-        relcount = 0
-        if not os.path.isabs(dirname):
-            curdir = os.getcwd()
-            head, tail = os.path.split(curdir)
-            relcount = 0
-            while head and tail:
-                relcount += 1
-                head, tail = os.path.split(head)
-            dirname = os.path.join(curdir, dirname)
-
-        # ?? foldername = os.path.basename(dirname)
-
-        rel_path = os.path.relpath(path, vol_path)
-
-        # Build the path arrays
-        name_path = []
-        cnid_path = []
-        head, tail = os.path.split(rel_path)
-        if not tail:
-            head, tail = os.path.split(head)
-        while head or tail:
-            if head:
-                attrs = [osx.ATTR_CMN_FILEID, 0, 0, 0, 0]
-                info = osx.getattrlist(os.path.join(vol_path, head), attrs, 0)
-                cnid_path.insert(0, info[0])
-                head, tail = os.path.split(head)
-                name_path.insert(0, tail)
-            else:
-                head, tail = os.path.split(head)
-        name_path.append(filename)
-        cnid_path.append(cnid)
-
-        url_lengths = [relcount, len(name_path) - relcount]
-
-        fileprops = Data(struct.pack(b"<QQQ", flags, 0x0F, 0))
-        volprops = Data(
-            struct.pack(
-                b"<QQQ",
-                0x81 | kCFURLVolumeSupportsPersistentIDs,
-                0x13EF | kCFURLVolumeSupportsPersistentIDs,
-                0,
-            )
-        )
-
-        toc = {
-            kBookmarkPath: name_path,
-            kBookmarkCNIDPath: cnid_path,
-            kBookmarkFileCreationDate: crtime,
-            kBookmarkFileProperties: fileprops,
-            kBookmarkContainingFolder: len(name_path) - 2,
-            kBookmarkVolumePath: vol_path,
-            kBookmarkVolumeIsRoot: vol_path == "/",
-            kBookmarkVolumeURL: URL("file://" + vol_path),
-            kBookmarkVolumeName: vol_name,
-            kBookmarkVolumeSize: vol_size,
-            kBookmarkVolumeCreationDate: vol_crtime,
-            kBookmarkVolumeUUID: str(vol_uuid).upper(),
-            kBookmarkVolumeProperties: volprops,
-            kBookmarkCreationOptions: 512,
-            kBookmarkWasFileReference: True,
-            kBookmarkUserName: "unknown",
-            kBookmarkUID: 99,
-        }
-
-        if relcount:
-            toc[kBookmarkURLLengths] = url_lengths
-
-        return Bookmark([(1, toc)])
-
-    def __repr__(self):
-        result = ["Bookmark(["]
-        for tid, toc in self.tocs:
-            result.append("(0x%x, {\n" % tid)
-            for k, v in toc.items():
-                if isinstance(k, str):
-                    kf = repr(k)
-                else:
-                    kf = "0x%04x" % k
-                result.append(f"  {kf}: {v!r}\n")
-            result.append("}),\n")
-        result.append("])")
-
-        return "".join(result)