cortav  Diff

			return str
		end
	};
}

function ss.classinstance(o)
	local g = getmetatable(o)
	if not o then return nil end
	local mm = getmetatable(g)
	if not o then return nil end
	if mm.__name == 'class' then
		return g
	else
		return nil
	end
end

................................................................................
	if #a ~= #b then return false end
	eq = eq or function(p,q) return p == q end
	for i = 1, #a do
		if not eq(a[i],b[i]) then return false end
	end
	return true
end
















































































































ss.uri = ss.declare {
	ident = 'uri';
	mk = function() return {
		class = nil;
		namespace = nil;
		path = nil;
................................................................................
			local s,r = rem:match '^([^:]+):(.*)$'
			s_class, rem = s,r
		end
		if not rem then
			ss.uri.exn('invalid URI “%s”', str):throw()
		end
		local s_ns do
			local s,r = rem:match '^//([^/]*)(.*)$'
			if s then s_ns, rem = s,r end
		end
		local h_query
		local s_frag
		local s_path if rem ~= '' then
			local s,q,r = rem:match '^([^?#]*)([?#]?)(.*)$'
			if s == '' then s = nil end
................................................................................
		me.namespace = dec(s_ns)
		me.path = dec(s_path)
		me.query = dec(s_query)
		me.frag = dec(s_frag)
	end;
	cast = {
		string = function(me)























			local function san(str, chars)
				-- TODO IRI support
				chars = chars or ''
				local ptn = '-a-zA-Z0-9_.,;'
				ptn = ptn .. chars
				return (str:gsub('[^'..ptn..']', function(c)
					if c == ' ' then return '+' end
					return string.format('%%%02X', string.byte(c))
				end))
			end

			if me.class == nil or next(me.class) == nil then
				return 'none:'
			end




			local parts = {
				table.concat(ss.map(san,me.class), '+') .. ':';
			}
			if me.namespace or me.auth or me.svc then
				table.insert(parts, '//')
				if me.auth then
					table.insert(parts, san(me.auth,':') .. '@')
				end
				if me.namespace then
					table.insert(parts, san(me.namespace))
				end
				if me.svc then
					table.insert(parts, ':' .. san(me.svc))
				end
				if me.path and not ss.str.begins(me.path, '/') then
					table.insert(parts, '/')
				end
			end
			if me.path then


				table.insert(parts, san(me.path,'+/=&'))
			end
			if me.query then

				table.insert(parts, '?' .. san(me.query,'?+/=&'))
			end
			if me.frag then

				table.insert(parts, '#' .. san(me.frag,'+/=&'))
			end
			return table.concat(parts)
		end;
	};
	fns = {
		canfetch = function(me)
			for id, pr in pairs(fetchableProtocols) do
				for _, p in ipairs(pr.proto) do
					if ss.match(me.class, p) then return id end
				end
			end
			return false
		end;
		fetch = function(me, env)
			local pid = me:canfetch()
			if (not pid) or fetchableProtocols[pid].fetch == nil then
				ss.uri.exn("URI “%s” is unfetchable", tostring(me)):throw()
			end
			local proto = fetchableProtocols[pid]

			return str
		end
	};
}

function ss.classinstance(o)
	local g = getmetatable(o)
	if not g then return nil end
	local mm = getmetatable(g)
	if not mm then return nil end
	if mm.__name == 'class' then
		return g
	else
		return nil
	end
end

................................................................................
	if #a ~= #b then return false end
	eq = eq or function(p,q) return p == q end
	for i = 1, #a do
		if not eq(a[i],b[i]) then return false end
	end
	return true
end

ss.os = {}
function ss.os.getcwd()
	return os.getenv 'PWD' -- :((( HAX
end

ss.path = ss.declare {
	ident = 'path';
	mk = function() return {
		relative = true;
		elts = {};
	} end;
	construct = function(me, o, rel)
		if type(o) == 'string' then
			if o:sub(1,1) == '/' then
				me.relative = false
			end
			me.elts = ss.str.split(ss.str.enc.ascii, o, '/')
		elseif type(o) == 'table' then
			me.elts = o
			me.relative = rel
		end
	end;
	clonesetup = function(me)
		me.elts = ss.clone(me.elts)
	end;
	cast = {
		string = function(me)
			return (me.relative and '' or '/') ..
				table.concat(me.elts, '/')
		end;
	};
	op = {
		sub = function(a,b)
			if a.relative ~= b.relative then
				return nil
			end

			local np = ss.path({}, true)
			local brk = false
			for i=1, math.max(#a.elts,#b.elts) do
				if not brk then
					if a.elts[i] ~= b.elts[i] then
						brk = true
					end
				end
				if brk then
					table.insert(np.elts, b.elts[i])
				end
			end

			return np
		end;
		sum = function(a,b)
			if b.relative == false then
				return nil
			end
			local n = a:clone()
			local i = #n.elts
			for j, v in ipairs(b.elts) do
				n.elts[i+j] = v
			end
			return n
		end;
		lt = function(a,b)
			-- '/a/b/c' < '/a/b/c/d'
			-- 'q/f/g' < 'q/f/g/p/d'
			-- '/a' !< '/b', '/a' !< 'a'
			if a.relative ~= b.relative then
				return false
			end
			if #a.elts > #b.elts then return false end
			for i=1, #a.elts do
				if a.elts[i] ~= b.elts[i] then
					return false
				end
			end
			return true
		end;
	};
	fns = {
		dir = function(me)
			local n = ss.copy(me.elts)
			n[#n] = nil
			local p = ss.path(n, me.relative)
		end;
		normalize = function(me)
			local np = ss.path({}, me.relative)
			for i, e in ipairs(me.elts) do
				if e == '..' then
					if me.relative and (
						next(np.elts) == nil or
						np.elts[#np.elts] == '..'
					) then
						table.insert(np.elts, '..')
					else
						table.remove(np.elts)
					end
				elseif e ~= '.' then
					table.insert(np.elts, e)
				end
			end
			return np
		end
	};
	cfns = {
		cwd = function()
			return ss.path(ss.os.getcwd())
		end;
	};
}

ss.uri = ss.declare {
	ident = 'uri';
	mk = function() return {
		class = nil;
		namespace = nil;
		path = nil;
................................................................................
			local s,r = rem:match '^([^:]+):(.*)$'
			s_class, rem = s,r
		end
		if not rem then
			ss.uri.exn('invalid URI “%s”', str):throw()
		end
		local s_ns do
			local s,r = rem:match '^//([^/?#]*)(.*)$'
			if s then s_ns, rem = s,r end
		end
		local h_query
		local s_frag
		local s_path if rem ~= '' then
			local s,q,r = rem:match '^([^?#]*)([?#]?)(.*)$'
			if s == '' then s = nil end
................................................................................
		me.namespace = dec(s_ns)
		me.path = dec(s_path)
		me.query = dec(s_query)
		me.frag = dec(s_frag)
	end;
	cast = {
		string = function(me)
			return me:construct('class','namespace','path','query','frag')
		end;
	};
	fns = {
		canfetch = function(me)
			for id, pr in pairs(fetchableProtocols) do
				for _, p in ipairs(pr.proto) do
					if ss.match(me.class, p) then return id end
				end
			end
			return false
		end;
		construct = function(me, ...)
			local parts = {}
			local function add(n, ...)
				if n == nil then return end
				table.insert(parts, me:part(n))
				add(...)
			end
			add(...)
			return table.concat(parts)
		end;
		part = function(me, p)
			local function san(str, chars)
				-- TODO IRI support
				chars = chars or ''
				local ptn = '-a-zA-Z0-9_.,;'
				ptn = ptn .. chars
				return (str:gsub('[^'..ptn..']', function(c)
					if c == ' ' then return '+' end
					return string.format('%%%02X', string.byte(c))
				end))
			end
			if p == 'class' then
				if me.class == nil or next(me.class) == nil then
					return 'none:'
				end
				return table.concat(ss.map(san,me.class), '+') .. ':';
			else
				if me[p] == nil then return '' end
				if p == 'namespace' then
					local parts = {}


					if me.namespace or me.auth or me.svc then
						table.insert(parts, '//')
						if me.auth then
							table.insert(parts, san(me.auth,':') .. '@')
						end
						if me.namespace then
							table.insert(parts, san(me.namespace))
						end
						if me.svc then
							table.insert(parts, ':' .. san(me.svc))
						end
						if me.path and not ss.str.begins(me.path, '/') then
							table.insert(parts, '/')
						end
					end

					return table.concat(parts)
				elseif p == 'path' then
					return san(me.path,'+/=&')


				elseif p == 'query' then
					return '?' .. san(me.query,'?+/=&')


				elseif p == 'frag' then
					return '#' .. san(me.frag,'+/=&')
				end

			end









		end;
		fetch = function(me, env)
			local pid = me:canfetch()
			if (not pid) or fetchableProtocols[pid].fetch == nil then
				ss.uri.exn("URI “%s” is unfetchable", tostring(me)):throw()
			end
			local proto = fetchableProtocols[pid]